assert.h@ 104212

Last change on this file since 104212 was 103638, checked in by vboxsync, 9 months ago
include/iprt/assert.h: Add AssertReleaseStmt() and AssertReleaseFailedStmt(), bugref:10373
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 92.1 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 AssertLogRelReturnVoid
1201	* Assert that an expression is true, return void if it isn't.
1202	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1203	*
1204	* @param expr Expression which should be true.
1205	*/
1206	#define AssertLogRelReturnVoid(expr) \
1207	do { \
1208	if (RT_LIKELY(!!(expr))) \
1209	{ /* likely */ } \
1210	else \
1211	{ \
1212	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1213	RTAssertPanic(); \
1214	return; \
1215	} \
1216	} while (0)
1217
1218	/** @def AssertLogRelBreak
1219	* Assert that an expression is true, break if it isn't.
1220	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1221	*
1222	* @param expr Expression which should be true.
1223	*/
1224	#define AssertLogRelBreak(expr) \
1225	if (RT_LIKELY(!!(expr))) \
1226	{ /* likely */ } \
1227	else if (1) \
1228	{ \
1229	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1230	RTAssertPanic(); \
1231	break; \
1232	} \
1233	else \
1234	break
1235
1236	/** @def AssertLogRelBreakStmt
1237	* Assert that an expression is true, execute \a stmt and break if it isn't.
1238	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1239	*
1240	* @param expr Expression which should be true.
1241	* @param stmt Statement to execute before break in case of a failed assertion.
1242	*/
1243	#define AssertLogRelBreakStmt(expr, stmt) \
1244	if (RT_LIKELY(!!(expr))) \
1245	{ /* likely */ } \
1246	else if (1) \
1247	{ \
1248	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1249	RTAssertPanic(); \
1250	stmt; \
1251	break; \
1252	} else \
1253	break
1254
1255	/** @def AssertLogRelStmt
1256	* Assert that an expression is true, return \a rc if it isn't.
1257	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1258	*
1259	* @param expr Expression which should be true.
1260	* @param stmt Statement to execute in case of a failed assertion.
1261	*/
1262	#define AssertLogRelStmt(expr, stmt) \
1263	do { \
1264	if (RT_LIKELY(!!(expr))) \
1265	{ /* likely */ } \
1266	else \
1267	{ \
1268	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1269	RTAssertPanic(); \
1270	stmt; \
1271	} \
1272	} while (0)
1273
1274	/** @def AssertLogRelMsg
1275	* Assert that an expression is true.
1276	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1277	*
1278	* @param expr Expression which should be true.
1279	* @param a printf argument list (in parenthesis).
1280	*/
1281	#define AssertLogRelMsg(expr, a) \
1282	do { \
1283	if (RT_LIKELY(!!(expr))) \
1284	{ /* likely */ } \
1285	else\
1286	{ \
1287	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1288	RTAssertLogRelMsg2(a); \
1289	RTAssertPanic(); \
1290	} \
1291	} while (0)
1292
1293	/** @def AssertLogRelMsgStmt
1294	* Assert that an expression is true, execute \a stmt and break if it isn't
1295	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1296	*
1297	* @param expr Expression which should be true.
1298	* @param a printf argument list (in parenthesis).
1299	* @param stmt Statement to execute in case of a failed assertion.
1300	*/
1301	#define AssertLogRelMsgStmt(expr, a, stmt) \
1302	do { \
1303	if (RT_LIKELY(!!(expr))) \
1304	{ /* likely */ } \
1305	else\
1306	{ \
1307	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1308	RTAssertLogRelMsg2(a); \
1309	RTAssertPanic(); \
1310	stmt; \
1311	} \
1312	} while (0)
1313
1314	/** @def AssertLogRelMsgReturn
1315	* Assert that an expression is true, return \a rc if it isn't.
1316	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1317	*
1318	* @param expr Expression which should be true.
1319	* @param a printf argument list (in parenthesis).
1320	* @param rc What is to be presented to return.
1321	*/
1322	#define AssertLogRelMsgReturn(expr, a, rc) \
1323	do { \
1324	if (RT_LIKELY(!!(expr))) \
1325	{ /* likely */ } \
1326	else\
1327	{ \
1328	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1329	RTAssertLogRelMsg2(a); \
1330	RTAssertPanic(); \
1331	return (rc); \
1332	} \
1333	} while (0)
1334
1335	/** @def AssertLogRelMsgReturnStmt
1336	* Assert that an expression is true, execute @a stmt and return @a rcRet if it
1337	* 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 before returning in case of a failed
1343	* assertion.
1344	* @param rcRet What is to be presented to return.
1345	*/
1346	#define AssertLogRelMsgReturnStmt(expr, a, stmt, rcRet) \
1347	do { \
1348	if (RT_LIKELY(!!(expr))) \
1349	{ /* likely */ } \
1350	else\
1351	{ \
1352	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1353	RTAssertLogRelMsg2(a); \
1354	RTAssertPanic(); \
1355	stmt; \
1356	return (rcRet); \
1357	} \
1358	} while (0)
1359
1360	/** @def AssertLogRelMsgReturnVoid
1361	* Assert that an expression is true, return (void) if it isn't.
1362	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1363	*
1364	* @param expr Expression which should be true.
1365	* @param a printf argument list (in parenthesis).
1366	*/
1367	#define AssertLogRelMsgReturnVoid(expr, a) \
1368	do { \
1369	if (RT_LIKELY(!!(expr))) \
1370	{ /* likely */ } \
1371	else\
1372	{ \
1373	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1374	RTAssertLogRelMsg2(a); \
1375	RTAssertPanic(); \
1376	return; \
1377	} \
1378	} while (0)
1379
1380	/** @def AssertLogRelMsgBreak
1381	* Assert that an expression is true, break if it isn't.
1382	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1383	*
1384	* @param expr Expression which should be true.
1385	* @param a printf argument list (in parenthesis).
1386	*/
1387	#define AssertLogRelMsgBreak(expr, a) \
1388	if (RT_LIKELY(!!(expr))) \
1389	{ /* likely */ } \
1390	else if (1) \
1391	{ \
1392	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1393	RTAssertLogRelMsg2(a); \
1394	RTAssertPanic(); \
1395	break; \
1396	} \
1397	else \
1398	break
1399
1400	/** @def AssertLogRelMsgBreakStmt
1401	* Assert that an expression is true, execute \a stmt and break if it isn't.
1402	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1403	*
1404	* @param expr Expression which should be true.
1405	* @param a printf argument list (in parenthesis).
1406	* @param stmt Statement to execute before break in case of a failed assertion.
1407	*/
1408	#define AssertLogRelMsgBreakStmt(expr, a, stmt) \
1409	if (RT_LIKELY(!!(expr))) \
1410	{ /* likely */ } \
1411	else if (1) \
1412	{ \
1413	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1414	RTAssertLogRelMsg2(a); \
1415	RTAssertPanic(); \
1416	stmt; \
1417	break; \
1418	} else \
1419	break
1420
1421	/** @def AssertLogRelFailed
1422	* An assertion failed.
1423	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1424	*/
1425	#define AssertLogRelFailed() \
1426	do { \
1427	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1428	RTAssertPanic(); \
1429	} while (0)
1430
1431	/** @def AssertLogRelFailedReturn
1432	* An assertion failed.
1433	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1434	*
1435	* @param rc What is to be presented to return.
1436	*/
1437	#define AssertLogRelFailedReturn(rc) \
1438	do { \
1439	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1440	RTAssertPanic(); \
1441	return (rc); \
1442	} while (0)
1443
1444	/** @def AssertLogRelFailedReturnVoid
1445	* An assertion failed, hit a breakpoint and return.
1446	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1447	*/
1448	#define AssertLogRelFailedReturnVoid() \
1449	do { \
1450	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1451	RTAssertPanic(); \
1452	return; \
1453	} while (0)
1454
1455	/** @def AssertLogRelFailedBreak
1456	* An assertion failed, break.
1457	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1458	*/
1459	#define AssertLogRelFailedBreak() \
1460	if (1) \
1461	{ \
1462	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1463	RTAssertPanic(); \
1464	break; \
1465	} else \
1466	break
1467
1468	/** @def AssertLogRelFailedBreakStmt
1469	* An assertion failed, execute \a stmt and break.
1470	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1471	*
1472	* @param stmt Statement to execute before break.
1473	*/
1474	#define AssertLogRelFailedBreakStmt(stmt) \
1475	if (1) \
1476	{ \
1477	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1478	RTAssertPanic(); \
1479	stmt; \
1480	break; \
1481	} else \
1482	break
1483
1484	/** @def AssertLogRelMsgFailed
1485	* An assertion failed.
1486	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1487	*
1488	* @param a printf argument list (in parenthesis).
1489	*/
1490	#define AssertLogRelMsgFailed(a) \
1491	do { \
1492	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1493	RTAssertLogRelMsg2(a); \
1494	RTAssertPanic(); \
1495	} while (0)
1496
1497	/** @def AssertLogRelMsgFailedStmt
1498	* An assertion failed, execute @a stmt.
1499	*
1500	* Strict builds will hit a breakpoint, non-strict will only do LogRel. The
1501	* statement will be executed in regardless of build type.
1502	*
1503	* @param a printf argument list (in parenthesis).
1504	* @param stmt Statement to execute after raising/logging the assertion.
1505	*/
1506	#define AssertLogRelMsgFailedStmt(a, stmt) \
1507	do { \
1508	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1509	RTAssertLogRelMsg2(a); \
1510	RTAssertPanic(); \
1511	stmt; \
1512	} while (0)
1513
1514	/** @def AssertLogRelMsgFailedReturn
1515	* An assertion failed, return \a rc.
1516	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1517	*
1518	* @param a printf argument list (in parenthesis).
1519	* @param rc What is to be presented to return.
1520	*/
1521	#define AssertLogRelMsgFailedReturn(a, rc) \
1522	do { \
1523	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1524	RTAssertLogRelMsg2(a); \
1525	RTAssertPanic(); \
1526	return (rc); \
1527	} while (0)
1528
1529	/** @def AssertLogRelMsgFailedReturnStmt
1530	* An assertion failed, execute @a stmt and return @a rc.
1531	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1532	*
1533	* @param a printf argument list (in parenthesis).
1534	* @param stmt Statement to execute before returning in case of a failed
1535	* assertion.
1536	* @param rc What is to be presented to return.
1537	*/
1538	#define AssertLogRelMsgFailedReturnStmt(a, stmt, rc) \
1539	do { \
1540	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1541	RTAssertLogRelMsg2(a); \
1542	RTAssertPanic(); \
1543	stmt; \
1544	return (rc); \
1545	} while (0)
1546
1547	/** @def AssertLogRelMsgFailedReturnVoid
1548	* An assertion failed, return void.
1549	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1550	*
1551	* @param a printf argument list (in parenthesis).
1552	*/
1553	#define AssertLogRelMsgFailedReturnVoid(a) \
1554	do { \
1555	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1556	RTAssertLogRelMsg2(a); \
1557	RTAssertPanic(); \
1558	return; \
1559	} while (0)
1560
1561	/** @def AssertLogRelMsgFailedReturnVoidStmt
1562	* An assertion failed, execute @a stmt and return void.
1563	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1564	*
1565	* @param a printf argument list (in parenthesis).
1566	* @param stmt Statement to execute before returning in case of a failed
1567	* assertion.
1568	*/
1569	#define AssertLogRelMsgFailedReturnVoidStmt(a, stmt) \
1570	do { \
1571	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1572	RTAssertLogRelMsg2(a); \
1573	RTAssertPanic(); \
1574	stmt; \
1575	return; \
1576	} while (0)
1577
1578	/** @def AssertLogRelMsgFailedBreak
1579	* An assertion failed, break.
1580	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1581	*
1582	* @param a printf argument list (in parenthesis).
1583	*/
1584	#define AssertLogRelMsgFailedBreak(a) \
1585	if (1)\
1586	{ \
1587	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1588	RTAssertLogRelMsg2(a); \
1589	RTAssertPanic(); \
1590	break; \
1591	} else \
1592	break
1593
1594	/** @def AssertLogRelMsgFailedBreakStmt
1595	* An assertion failed, execute \a stmt and break.
1596	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1597	*
1598	* @param a printf argument list (in parenthesis).
1599	* @param stmt Statement to execute before break.
1600	*/
1601	#define AssertLogRelMsgFailedBreakStmt(a, stmt) \
1602	if (1) \
1603	{ \
1604	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1605	RTAssertLogRelMsg2(a); \
1606	RTAssertPanic(); \
1607	stmt; \
1608	break; \
1609	} else \
1610	break
1611
1612	/** @} */
1613
1614
1615
1616	/** @name Release Assertions
1617	*
1618	* These assertions are always enabled.
1619	* @{
1620	*/
1621
1622	/** @def RTAssertReleasePanic()
1623	* Invokes RTAssertShouldPanic and RTAssertDoPanic.
1624	*
1625	* It might seem odd that RTAssertShouldPanic is necessary when its result isn't
1626	* checked, but it's done since RTAssertShouldPanic is overrideable and might be
1627	* used to bail out before taking down the system (the VMMR0 case).
1628	*/
1629	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1630	# define RTAssertReleasePanic() do { RTAssertShouldPanic(); RTAssertDoPanic(); } while (0)
1631	#else
1632	# define RTAssertReleasePanic() do { } while (0)
1633	#endif
1634
1635
1636	/** @def AssertRelease
1637	* Assert that an expression is true. If it's not hit a breakpoint.
1638	*
1639	* @param expr Expression which should be true.
1640	*/
1641	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1642	# define AssertRelease(expr) \
1643	do { \
1644	if (RT_LIKELY(!!(expr))) \
1645	{ /* likely */ } \
1646	else \
1647	{ \
1648	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1649	RTAssertReleasePanic(); \
1650	} \
1651	} while (0)
1652	#else
1653	# define AssertRelease(expr) do { } while (0)
1654	#endif
1655
1656	/** @def AssertReleaseStmt
1657	* Assert that an expression is true. If false, hit breakpoint and execute the
1658	* statement.
1659	* @param expr Expression which should be true.
1660	* @param stmt Statement to execute on failure.
1661	*/
1662	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1663	# define AssertReleaseStmt(expr, stmt) \
1664	do { \
1665	if (RT_LIKELY(!!(expr))) \
1666	{ /* likely */ } \
1667	else \
1668	{ \
1669	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1670	RTAssertReleasePanic(); \
1671	stmt; \
1672	} \
1673	} while (0)
1674	#else
1675	# define AssertReleaseStmt(expr, stmt) \
1676	do { \
1677	if (RT_LIKELY(!!(expr))) \
1678	{ /* likely */ } \
1679	else \
1680	{ \
1681	stmt; \
1682	} \
1683	} while (0)
1684	#endif
1685
1686	/** @def AssertReleaseReturn
1687	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1688	*
1689	* @param expr Expression which should be true.
1690	* @param rc What is to be presented to return.
1691	*/
1692	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1693	# define AssertReleaseReturn(expr, rc) \
1694	do { \
1695	if (RT_LIKELY(!!(expr))) \
1696	{ /* likely */ } \
1697	else \
1698	{ \
1699	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1700	RTAssertReleasePanic(); \
1701	return (rc); \
1702	} \
1703	} while (0)
1704	#else
1705	# define AssertReleaseReturn(expr, rc) \
1706	do { \
1707	if (RT_LIKELY(!!(expr))) \
1708	{ /* likely */ } \
1709	else \
1710	return (rc); \
1711	} while (0)
1712	#endif
1713
1714	/** @def AssertReleaseReturnVoid
1715	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1716	*
1717	* @param expr Expression which should be true.
1718	*/
1719	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1720	# define AssertReleaseReturnVoid(expr) \
1721	do { \
1722	if (RT_LIKELY(!!(expr))) \
1723	{ /* likely */ } \
1724	else \
1725	{ \
1726	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1727	RTAssertReleasePanic(); \
1728	return; \
1729	} \
1730	} while (0)
1731	#else
1732	# define AssertReleaseReturnVoid(expr) \
1733	do { \
1734	if (RT_LIKELY(!!(expr))) \
1735	{ /* likely */ } \
1736	else \
1737	return; \
1738	} while (0)
1739	#endif
1740
1741
1742	/** @def AssertReleaseBreak
1743	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1744	*
1745	* @param expr Expression which should be true.
1746	*/
1747	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1748	# define AssertReleaseBreak(expr) \
1749	if (RT_LIKELY(!!(expr))) \
1750	{ /* likely */ } \
1751	else if (1) \
1752	{ \
1753	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1754	RTAssertReleasePanic(); \
1755	break; \
1756	} else \
1757	break
1758	#else
1759	# define AssertReleaseBreak(expr) \
1760	if (RT_LIKELY(!!(expr))) \
1761	{ /* likely */ } \
1762	else \
1763	break
1764	#endif
1765
1766	/** @def AssertReleaseBreakStmt
1767	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1768	*
1769	* @param expr Expression which should be true.
1770	* @param stmt Statement to execute before break in case of a failed assertion.
1771	*/
1772	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1773	# define AssertReleaseBreakStmt(expr, stmt) \
1774	if (RT_LIKELY(!!(expr))) \
1775	{ /* likely */ } \
1776	else if (1) \
1777	{ \
1778	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1779	RTAssertReleasePanic(); \
1780	stmt; \
1781	break; \
1782	} else \
1783	break
1784	#else
1785	# define AssertReleaseBreakStmt(expr, stmt) \
1786	if (RT_LIKELY(!!(expr))) \
1787	{ /* likely */ } \
1788	else if (1) \
1789	{ \
1790	stmt; \
1791	break; \
1792	} else \
1793	break
1794	#endif
1795
1796
1797	/** @def AssertReleaseMsg
1798	* Assert that an expression is true, print the message and hit a breakpoint if it isn't.
1799	*
1800	* @param expr Expression which should be true.
1801	* @param a printf argument list (in parenthesis).
1802	*/
1803	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1804	# define AssertReleaseMsg(expr, a) \
1805	do { \
1806	if (RT_LIKELY(!!(expr))) \
1807	{ /* likely */ } \
1808	else \
1809	{ \
1810	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1811	RTAssertMsg2Weak a; \
1812	RTAssertReleasePanic(); \
1813	} \
1814	} while (0)
1815	#else
1816	# define AssertReleaseMsg(expr, a) do { } while (0)
1817	#endif
1818
1819	/** @def AssertReleaseMsgReturn
1820	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1821	*
1822	* @param expr Expression which should be true.
1823	* @param a printf argument list (in parenthesis).
1824	* @param rc What is to be presented to return.
1825	*/
1826	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1827	# define AssertReleaseMsgReturn(expr, a, rc) \
1828	do { \
1829	if (RT_LIKELY(!!(expr))) \
1830	{ /* likely */ } \
1831	else \
1832	{ \
1833	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1834	RTAssertMsg2Weak a; \
1835	RTAssertReleasePanic(); \
1836	return (rc); \
1837	} \
1838	} while (0)
1839	#else
1840	# define AssertReleaseMsgReturn(expr, a, rc) \
1841	do { \
1842	if (RT_LIKELY(!!(expr))) \
1843	{ /* likely */ } \
1844	else \
1845	return (rc); \
1846	} while (0)
1847	#endif
1848
1849	/** @def AssertReleaseMsgReturnVoid
1850	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1851	*
1852	* @param expr Expression which should be true.
1853	* @param a printf argument list (in parenthesis).
1854	*/
1855	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1856	# define AssertReleaseMsgReturnVoid(expr, a) \
1857	do { \
1858	if (RT_LIKELY(!!(expr))) \
1859	{ /* likely */ } \
1860	else \
1861	{ \
1862	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1863	RTAssertMsg2Weak a; \
1864	RTAssertReleasePanic(); \
1865	return; \
1866	} \
1867	} while (0)
1868	#else
1869	# define AssertReleaseMsgReturnVoid(expr, a) \
1870	do { \
1871	if (RT_LIKELY(!!(expr))) \
1872	{ /* likely */ } \
1873	else \
1874	return; \
1875	} while (0)
1876	#endif
1877
1878
1879	/** @def AssertReleaseMsgBreak
1880	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1881	*
1882	* @param expr Expression which should be true.
1883	* @param a printf argument list (in parenthesis).
1884	*/
1885	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1886	# define AssertReleaseMsgBreak(expr, a) \
1887	if (RT_LIKELY(!!(expr))) \
1888	{ /* likely */ } \
1889	else if (1) \
1890	{ \
1891	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1892	RTAssertMsg2Weak a; \
1893	RTAssertReleasePanic(); \
1894	break; \
1895	} else \
1896	break
1897	#else
1898	# define AssertReleaseMsgBreak(expr, a) \
1899	if (RT_LIKELY(!!(expr))) \
1900	{ /* likely */ } \
1901	else if (1) \
1902	break; \
1903	else \
1904	break
1905	#endif
1906
1907	/** @def AssertReleaseMsgBreakStmt
1908	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1909	*
1910	* @param expr Expression which should be true.
1911	* @param a printf argument list (in parenthesis).
1912	* @param stmt Statement to execute before break in case of a failed assertion.
1913	*/
1914	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1915	# define AssertReleaseMsgBreakStmt(expr, a, stmt) \
1916	if (RT_LIKELY(!!(expr))) \
1917	{ /* likely */ } \
1918	else if (1) \
1919	{ \
1920	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1921	RTAssertMsg2Weak a; \
1922	RTAssertReleasePanic(); \
1923	stmt; \
1924	break; \
1925	} else \
1926	break
1927	#else
1928	# define AssertReleaseMsgBreakStmt(expr, a, stmt) \
1929	if (RT_LIKELY(!!(expr))) \
1930	{ /* likely */ } \
1931	else if (1) \
1932	{ \
1933	stmt; \
1934	break; \
1935	} else \
1936	break
1937	#endif
1938
1939
1940	/** @def AssertReleaseFailed
1941	* An assertion failed, hit a breakpoint.
1942	*/
1943	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1944	# define AssertReleaseFailed() \
1945	do { \
1946	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1947	RTAssertReleasePanic(); \
1948	} while (0)
1949	#else
1950	# define AssertReleaseFailed() do { } while (0)
1951	#endif
1952
1953	/** @def AssertReleaseFailedStmt
1954	* An assertion failed, hit breakpoint and execute statement.
1955	*/
1956	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1957	# define AssertReleaseFailedStmt(stmt) \
1958	do { \
1959	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1960	RTAssertReleasePanic(); \
1961	stmt; \
1962	} while (0)
1963	#else
1964	# define AssertReleaseFailedStmt(stmt) do { stmt; } while (0)
1965	#endif
1966
1967	/** @def AssertReleaseFailedReturn
1968	* An assertion failed, hit a breakpoint and return.
1969	*
1970	* @param rc What is to be presented to return.
1971	*/
1972	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1973	# define AssertReleaseFailedReturn(rc) \
1974	do { \
1975	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1976	RTAssertReleasePanic(); \
1977	return (rc); \
1978	} while (0)
1979	#else
1980	# define AssertReleaseFailedReturn(rc) \
1981	do { return (rc); } while (0)
1982	#endif
1983
1984	/** @def AssertReleaseFailedReturnVoid
1985	* An assertion failed, hit a breakpoint and return.
1986	*/
1987	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1988	# define AssertReleaseFailedReturnVoid() \
1989	do { \
1990	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1991	RTAssertReleasePanic(); \
1992	return; \
1993	} while (0)
1994	#else
1995	# define AssertReleaseFailedReturnVoid() \
1996	do { return; } while (0)
1997	#endif
1998
1999	/** @def AssertReleaseFailedBreak
2000	* An assertion failed, hit a breakpoint and break.
2001	*/
2002	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2003	# define AssertReleaseFailedBreak() \
2004	if (1) { \
2005	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2006	RTAssertReleasePanic(); \
2007	break; \
2008	} else \
2009	break
2010	#else
2011	# define AssertReleaseFailedBreak() \
2012	if (1) \
2013	break; \
2014	else \
2015	break
2016	#endif
2017
2018	/** @def AssertReleaseFailedBreakStmt
2019	* An assertion failed, hit a breakpoint and break.
2020	*
2021	* @param stmt Statement to execute before break.
2022	*/
2023	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2024	# define AssertReleaseFailedBreakStmt(stmt) \
2025	if (1) { \
2026	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2027	RTAssertReleasePanic(); \
2028	stmt; \
2029	break; \
2030	} else \
2031	break
2032	#else
2033	# define AssertReleaseFailedBreakStmt(stmt) \
2034	if (1) { \
2035	stmt; \
2036	break; \
2037	} else \
2038	break
2039	#endif
2040
2041	/** @def AssertReleaseMsgFailed
2042	* An assertion failed, print a message and hit a breakpoint.
2043	*
2044	* @param a printf argument list (in parenthesis).
2045	*/
2046	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2047	# define AssertReleaseMsgFailed(a) \
2048	do { \
2049	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2050	RTAssertMsg2Weak a; \
2051	RTAssertReleasePanic(); \
2052	} while (0)
2053	#else
2054	# define AssertReleaseMsgFailed(a) do { } while (0)
2055	#endif
2056
2057	/** @def AssertReleaseMsgFailedReturn
2058	* An assertion failed, print a message, hit a breakpoint and return.
2059	*
2060	* @param a printf argument list (in parenthesis).
2061	* @param rc What is to be presented to return.
2062	*/
2063	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2064	# define AssertReleaseMsgFailedReturn(a, rc) \
2065	do { \
2066	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2067	RTAssertMsg2Weak a; \
2068	RTAssertReleasePanic(); \
2069	return (rc); \
2070	} while (0)
2071	#else
2072	# define AssertReleaseMsgFailedReturn(a, rc) \
2073	do { return (rc); } while (0)
2074	#endif
2075
2076	/** @def AssertReleaseMsgFailedReturnVoid
2077	* An assertion failed, print a message, hit a breakpoint and return.
2078	*
2079	* @param a printf argument list (in parenthesis).
2080	*/
2081	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2082	# define AssertReleaseMsgFailedReturnVoid(a) \
2083	do { \
2084	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2085	RTAssertMsg2Weak a; \
2086	RTAssertReleasePanic(); \
2087	return; \
2088	} while (0)
2089	#else
2090	# define AssertReleaseMsgFailedReturnVoid(a) \
2091	do { return; } while (0)
2092	#endif
2093
2094
2095	/** @def AssertReleaseMsgFailedBreak
2096	* An assertion failed, print a message, hit a breakpoint and break.
2097	*
2098	* @param a printf argument list (in parenthesis).
2099	*/
2100	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2101	# define AssertReleaseMsgFailedBreak(a) \
2102	if (1) { \
2103	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2104	RTAssertMsg2Weak a; \
2105	RTAssertReleasePanic(); \
2106	break; \
2107	} else \
2108	break
2109	#else
2110	# define AssertReleaseMsgFailedBreak(a) \
2111	if (1) \
2112	break; \
2113	else \
2114	break
2115	#endif
2116
2117	/** @def AssertReleaseMsgFailedBreakStmt
2118	* An assertion failed, print a message, hit a breakpoint and break.
2119	*
2120	* @param a printf argument list (in parenthesis).
2121	* @param stmt Statement to execute before break.
2122	*/
2123	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2124	# define AssertReleaseMsgFailedBreakStmt(a, stmt) \
2125	if (1) { \
2126	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2127	RTAssertMsg2Weak a; \
2128	RTAssertReleasePanic(); \
2129	stmt; \
2130	break; \
2131	} else \
2132	break
2133	#else
2134	# define AssertReleaseMsgFailedBreakStmt(a, stmt) \
2135	if (1) { \
2136	stmt; \
2137	break; \
2138	} else \
2139	break
2140	#endif
2141	/** @} */
2142
2143
2144
2145	/** @name Fatal Assertions
2146	* These are similar to release assertions except that you cannot ignore them in
2147	* any way, they will loop for ever if RTAssertDoPanic returns.
2148	*
2149	* @{
2150	*/
2151
2152	/** @def AssertFatal
2153	* Assert that an expression is true. If it's not hit a breakpoint (for ever).
2154	*
2155	* @param expr Expression which should be true.
2156	*/
2157	#define AssertFatal(expr) \
2158	do { \
2159	if (RT_LIKELY(!!(expr))) \
2160	{ /* likely */ } \
2161	else \
2162	for (;;) \
2163	{ \
2164	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2165	RTAssertReleasePanic(); \
2166	} \
2167	} while (0)
2168
2169	/** @def AssertFatalMsg
2170	* Assert that an expression is true, print the message and hit a breakpoint (for ever) if it isn't.
2171	*
2172	* @param expr Expression which should be true.
2173	* @param a printf argument list (in parenthesis).
2174	*/
2175	#define AssertFatalMsg(expr, a) \
2176	do { \
2177	if (RT_LIKELY(!!(expr))) \
2178	{ /* likely */ } \
2179	else \
2180	for (;;) \
2181	{ \
2182	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2183	RTAssertMsg2Weak a; \
2184	RTAssertReleasePanic(); \
2185	} \
2186	} while (0)
2187
2188	/** @def AssertFatalFailed
2189	* An assertion failed, hit a breakpoint (for ever).
2190	*/
2191	#define AssertFatalFailed() \
2192	do { \
2193	for (;;) \
2194	{ \
2195	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2196	RTAssertReleasePanic(); \
2197	} \
2198	} while (0)
2199
2200	/** @def AssertFatalMsgFailed
2201	* An assertion failed, print a message and hit a breakpoint (for ever).
2202	*
2203	* @param a printf argument list (in parenthesis).
2204	*/
2205	#define AssertFatalMsgFailed(a) \
2206	do { \
2207	for (;;) \
2208	{ \
2209	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2210	RTAssertMsg2Weak a; \
2211	RTAssertReleasePanic(); \
2212	} \
2213	} while (0)
2214
2215	/** @} */
2216
2217
2218
2219	/** @name Convenience Assertions Macros
2220	* @{
2221	*/
2222
2223	/** @def AssertRC
2224	* Asserts a iprt status code successful.
2225	*
2226	* On failure it will print info about the rc and hit a breakpoint.
2227	*
2228	* @param rc iprt status code.
2229	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2230	*/
2231	#define AssertRC(rc) AssertMsgRC(rc, ("%Rra\n", (rc)))
2232
2233	/** @def AssertRCStmt
2234	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and execute
2235	* @a stmt if it isn't.
2236	*
2237	* @param rc iprt status code.
2238	* @param stmt Statement to execute before returning in case of a failed
2239	* assertion.
2240	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2241	*/
2242	#define AssertRCStmt(rc, stmt) AssertMsgRCStmt(rc, ("%Rra\n", (rc)), stmt)
2243
2244	/** @def AssertRCReturn
2245	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
2246	*
2247	* @param rc iprt status code.
2248	* @param rcRet What is to be presented to return.
2249	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2250	*/
2251	#define AssertRCReturn(rc, rcRet) AssertMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2252
2253	/** @def AssertRCReturnStmt
2254	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2255	* @a stmt and returns @a rcRet if it isn't.
2256	*
2257	* @param rc iprt status code.
2258	* @param stmt Statement to execute before returning in case of a failed
2259	* assertion.
2260	* @param rcRet What is to be presented to return.
2261	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2262	*/
2263	#define AssertRCReturnStmt(rc, stmt, rcRet) AssertMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
2264
2265	/** @def AssertRCReturnVoid
2266	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
2267	*
2268	* @param rc iprt status code.
2269	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2270	*/
2271	#define AssertRCReturnVoid(rc) AssertMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2272
2273	/** @def AssertRCReturnVoidStmt
2274	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
2275	* execute the given statement/return if it isn't.
2276	*
2277	* @param rc iprt status code.
2278	* @param stmt Statement to execute before returning on failure.
2279	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2280	*/
2281	#define AssertRCReturnVoidStmt(rc, stmt) AssertMsgRCReturnVoidStmt(rc, ("%Rra\n", (rc)), stmt)
2282
2283	/** @def AssertRCBreak
2284	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2285	*
2286	* @param rc iprt status code.
2287	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2288	*/
2289	#define AssertRCBreak(rc) AssertMsgRCBreak(rc, ("%Rra\n", (rc)))
2290
2291	/** @def AssertRCBreakStmt
2292	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2293	*
2294	* @param rc iprt status code.
2295	* @param stmt Statement to execute before break in case of a failed assertion.
2296	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2297	*/
2298	#define AssertRCBreakStmt(rc, stmt) AssertMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2299
2300	/** @def AssertMsgRC
2301	* Asserts a iprt status code successful.
2302	*
2303	* It prints a custom message and hits a breakpoint on FAILURE.
2304	*
2305	* @param rc iprt status code.
2306	* @param msg printf argument list (in parenthesis).
2307	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2308	*/
2309	#define AssertMsgRC(rc, msg) \
2310	do { AssertMsg(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2311
2312	/** @def AssertMsgRCStmt
2313	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and
2314	* execute @a stmt if it isn't.
2315	*
2316	* @param rc iprt status code.
2317	* @param msg printf argument list (in parenthesis).
2318	* @param stmt Statement to execute before returning in case of a failed
2319	* assertion.
2320	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2321	*/
2322	#define AssertMsgRCStmt(rc, msg, stmt) \
2323	do { AssertMsgStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
2324
2325	/** @def AssertMsgRCReturn
2326	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
2327	* @a rcRet if it isn't.
2328	*
2329	* @param rc iprt status code.
2330	* @param msg printf argument list (in parenthesis).
2331	* @param rcRet What is to be presented to return.
2332	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2333	*/
2334	#define AssertMsgRCReturn(rc, msg, rcRet) \
2335	do { AssertMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)
2336
2337	/** @def AssertMsgRCReturnStmt
2338	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2339	* @a stmt and return @a rcRet if it isn't.
2340	*
2341	* @param rc iprt status code.
2342	* @param msg printf argument list (in parenthesis).
2343	* @param stmt Statement to execute before returning in case of a failed
2344	* assertion.
2345	* @param rcRet What is to be presented to return.
2346	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2347	*/
2348	#define AssertMsgRCReturnStmt(rc, msg, stmt, rcRet) \
2349	do { AssertMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)
2350
2351	/** @def AssertMsgRCReturnVoid
2352	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
2353	* void if it isn't.
2354	*
2355	* @param rc iprt status code.
2356	* @param msg printf argument list (in parenthesis).
2357	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2358	*/
2359	#define AssertMsgRCReturnVoid(rc, msg) \
2360	do { AssertMsgReturnVoid(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2361
2362	/** @def AssertMsgRCReturnVoidStmt
2363	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2364	* @a stmt and return void if it isn't.
2365	*
2366	* @param rc iprt status code.
2367	* @param msg printf argument list (in parenthesis).
2368	* @param stmt Statement to execute before break in case of a failed assertion.
2369	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2370	*/
2371	#define AssertMsgRCReturnVoidStmt(rc, msg, stmt) \
2372	do { AssertMsgReturnVoidStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
2373
2374	/** @def AssertMsgRCBreak
2375	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break
2376	* if it isn't.
2377	*
2378	* @param rc iprt status code.
2379	* @param msg printf argument list (in parenthesis).
2380	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2381	*/
2382	#define AssertMsgRCBreak(rc, msg) \
2383	if (1) { AssertMsgBreak(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)
2384
2385	/** @def AssertMsgRCBreakStmt
2386	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2387	* @a stmt and break if it isn't.
2388	*
2389	* @param rc iprt status code.
2390	* @param msg printf argument list (in parenthesis).
2391	* @param stmt Statement to execute before break in case of a failed assertion.
2392	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2393	*/
2394	#define AssertMsgRCBreakStmt(rc, msg, stmt) \
2395	if (1) { AssertMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)
2396
2397	/** @def AssertRCSuccess
2398	* Asserts an iprt status code equals VINF_SUCCESS.
2399	*
2400	* On failure it will print info about the rc and hit a breakpoint.
2401	*
2402	* @param rc iprt status code.
2403	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2404	*/
2405	#define AssertRCSuccess(rc) do { AssertMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)
2406
2407	/** @def AssertRCSuccessReturn
2408	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2409	*
2410	* @param rc iprt status code.
2411	* @param rcRet What is to be presented to return.
2412	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2413	*/
2414	#define AssertRCSuccessReturn(rc, rcRet) AssertMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2415
2416	/** @def AssertRCSuccessReturnVoid
2417	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2418	*
2419	* @param rc iprt status code.
2420	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2421	*/
2422	#define AssertRCSuccessReturnVoid(rc) AssertMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2423
2424	/** @def AssertRCSuccessBreak
2425	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2426	*
2427	* @param rc iprt status code.
2428	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2429	*/
2430	#define AssertRCSuccessBreak(rc) AssertMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2431
2432	/** @def AssertRCSuccessBreakStmt
2433	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2434	*
2435	* @param rc iprt status code.
2436	* @param stmt Statement to execute before break in case of a failed assertion.
2437	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2438	*/
2439	#define AssertRCSuccessBreakStmt(rc, stmt) AssertMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2440
2441
2442	/** @def AssertLogRelRC
2443	* Asserts a iprt status code successful.
2444	*
2445	* @param rc iprt status code.
2446	* @remark rc is referenced multiple times.
2447	*/
2448	#define AssertLogRelRC(rc) AssertLogRelMsgRC(rc, ("%Rra\n", (rc)))
2449
2450	/** @def AssertLogRelRCReturn
2451	* Asserts a iprt status code successful, returning \a rc 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.
2456	*/
2457	#define AssertLogRelRCReturn(rc, rcRet) AssertLogRelMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2458
2459	/** @def AssertLogRelRCReturnStmt
2460	* Asserts a iprt status code successful, executing \a stmt and returning \a rc
2461	* if it isn't.
2462	*
2463	* @param rc iprt status code.
2464	* @param stmt Statement to execute before returning in case of a failed
2465	* assertion.
2466	* @param rcRet What is to be presented to return.
2467	* @remark rc is referenced multiple times.
2468	*/
2469	#define AssertLogRelRCReturnStmt(rc, stmt, rcRet) AssertLogRelMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
2470
2471	/** @def AssertLogRelRCReturnVoid
2472	* Asserts a iprt status code successful, returning (void) if it isn't.
2473	*
2474	* @param rc iprt status code.
2475	* @remark rc is referenced multiple times.
2476	*/
2477	#define AssertLogRelRCReturnVoid(rc) AssertLogRelMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2478
2479	/** @def AssertLogRelRCBreak
2480	* Asserts a iprt status code successful, breaking if it isn't.
2481	*
2482	* @param rc iprt status code.
2483	* @remark rc is referenced multiple times.
2484	*/
2485	#define AssertLogRelRCBreak(rc) AssertLogRelMsgRCBreak(rc, ("%Rra\n", (rc)))
2486
2487	/** @def AssertLogRelRCBreakStmt
2488	* Asserts a iprt status code successful, execute \a statement and break if it isn't.
2489	*
2490	* @param rc iprt status code.
2491	* @param stmt Statement to execute before break in case of a failed assertion.
2492	* @remark rc is referenced multiple times.
2493	*/
2494	#define AssertLogRelRCBreakStmt(rc, stmt) AssertLogRelMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2495
2496	/** @def AssertLogRelMsgRC
2497	* Asserts a iprt status code successful.
2498	*
2499	* @param rc iprt status code.
2500	* @param msg printf argument list (in parenthesis).
2501	* @remark rc is referenced multiple times.
2502	*/
2503	#define AssertLogRelMsgRC(rc, msg) AssertLogRelMsg(RT_SUCCESS_NP(rc), msg)
2504
2505	/** @def AssertLogRelMsgRCReturn
2506	* Asserts a iprt status code successful.
2507	*
2508	* @param rc iprt status code.
2509	* @param msg printf argument list (in parenthesis).
2510	* @param rcRet What is to be presented to return.
2511	* @remark rc is referenced multiple times.
2512	*/
2513	#define AssertLogRelMsgRCReturn(rc, msg, rcRet) AssertLogRelMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2514
2515	/** @def AssertLogRelMsgRCReturnStmt
2516	* Asserts a iprt status code successful, execute \a stmt and return on
2517	* failure.
2518	*
2519	* @param rc iprt status code.
2520	* @param msg printf argument list (in parenthesis).
2521	* @param stmt Statement to execute before returning in case of a failed
2522	* assertion.
2523	* @param rcRet What is to be presented to return.
2524	* @remark rc is referenced multiple times.
2525	*/
2526	#define AssertLogRelMsgRCReturnStmt(rc, msg, stmt, rcRet) AssertLogRelMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet)
2527
2528	/** @def AssertLogRelMsgRCReturnVoid
2529	* Asserts a iprt status code successful.
2530	*
2531	* @param rc iprt status code.
2532	* @param msg printf argument list (in parenthesis).
2533	* @remark rc is referenced multiple times.
2534	*/
2535	#define AssertLogRelMsgRCReturnVoid(rc, msg) AssertLogRelMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2536
2537	/** @def AssertLogRelMsgRCBreak
2538	* Asserts a iprt status code successful.
2539	*
2540	* @param rc iprt status code.
2541	* @param msg printf argument list (in parenthesis).
2542	* @remark rc is referenced multiple times.
2543	*/
2544	#define AssertLogRelMsgRCBreak(rc, msg) AssertLogRelMsgBreak(RT_SUCCESS(rc), msg)
2545
2546	/** @def AssertLogRelMsgRCBreakStmt
2547	* Asserts a iprt status code successful, execute \a stmt and break if it isn't.
2548	*
2549	* @param rc iprt status code.
2550	* @param msg printf argument list (in parenthesis).
2551	* @param stmt Statement to execute before break in case of a failed assertion.
2552	* @remark rc is referenced multiple times.
2553	*/
2554	#define AssertLogRelMsgRCBreakStmt(rc, msg, stmt) AssertLogRelMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2555
2556	/** @def AssertLogRelRCSuccess
2557	* Asserts that an iprt status code equals VINF_SUCCESS.
2558	*
2559	* @param rc iprt status code.
2560	* @remark rc is referenced multiple times.
2561	*/
2562	#define AssertLogRelRCSuccess(rc) AssertLogRelMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2563
2564	/** @def AssertLogRelRCSuccessReturn
2565	* Asserts that an iprt status code equals VINF_SUCCESS.
2566	*
2567	* @param rc iprt status code.
2568	* @param rcRet What is to be presented to return.
2569	* @remark rc is referenced multiple times.
2570	*/
2571	#define AssertLogRelRCSuccessReturn(rc, rcRet) AssertLogRelMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2572
2573	/** @def AssertLogRelRCSuccessReturnVoid
2574	* Asserts that an iprt status code equals VINF_SUCCESS.
2575	*
2576	* @param rc iprt status code.
2577	* @remark rc is referenced multiple times.
2578	*/
2579	#define AssertLogRelRCSuccessReturnVoid(rc) AssertLogRelMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2580
2581	/** @def AssertLogRelRCSuccessBreak
2582	* Asserts that an iprt status code equals VINF_SUCCESS.
2583	*
2584	* @param rc iprt status code.
2585	* @remark rc is referenced multiple times.
2586	*/
2587	#define AssertLogRelRCSuccessBreak(rc) AssertLogRelMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2588
2589	/** @def AssertLogRelRCSuccessBreakStmt
2590	* Asserts that an iprt status code equals VINF_SUCCESS.
2591	*
2592	* @param rc iprt status code.
2593	* @param stmt Statement to execute before break in case of a failed assertion.
2594	* @remark rc is referenced multiple times.
2595	*/
2596	#define AssertLogRelRCSuccessBreakStmt(rc, stmt) AssertLogRelMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2597
2598
2599	/** @def AssertReleaseRC
2600	* Asserts a iprt status code successful.
2601	*
2602	* On failure information about the error will be printed and a breakpoint hit.
2603	*
2604	* @param rc iprt status code.
2605	* @remark rc is referenced multiple times.
2606	*/
2607	#define AssertReleaseRC(rc) AssertReleaseMsgRC(rc, ("%Rra\n", (rc)))
2608
2609	/** @def AssertReleaseRCReturn
2610	* Asserts a iprt status code successful, returning if it isn't.
2611	*
2612	* On failure information about the error will be printed, a breakpoint hit
2613	* and finally returning from the function if the breakpoint is somehow ignored.
2614	*
2615	* @param rc iprt status code.
2616	* @param rcRet What is to be presented to return.
2617	* @remark rc is referenced multiple times.
2618	*/
2619	#define AssertReleaseRCReturn(rc, rcRet) AssertReleaseMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2620
2621	/** @def AssertReleaseRCReturnVoid
2622	* Asserts a iprt status code successful, returning if it isn't.
2623	*
2624	* On failure information about the error will be printed, a breakpoint hit
2625	* and finally returning from the function if the breakpoint is somehow ignored.
2626	*
2627	* @param rc iprt status code.
2628	* @remark rc is referenced multiple times.
2629	*/
2630	#define AssertReleaseRCReturnVoid(rc) AssertReleaseMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2631
2632	/** @def AssertReleaseRCBreak
2633	* Asserts a iprt status code successful, breaking if it isn't.
2634	*
2635	* On failure information about the error will be printed, a breakpoint hit
2636	* and finally breaking the current statement if the breakpoint is somehow ignored.
2637	*
2638	* @param rc iprt status code.
2639	* @remark rc is referenced multiple times.
2640	*/
2641	#define AssertReleaseRCBreak(rc) AssertReleaseMsgRCBreak(rc, ("%Rra\n", (rc)))
2642
2643	/** @def AssertReleaseRCBreakStmt
2644	* Asserts a iprt status code successful, break if it isn't.
2645	*
2646	* On failure information about the error will be printed, a breakpoint hit
2647	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2648	*
2649	* @param rc iprt status code.
2650	* @param stmt Statement to execute before break in case of a failed assertion.
2651	* @remark rc is referenced multiple times.
2652	*/
2653	#define AssertReleaseRCBreakStmt(rc, stmt) AssertReleaseMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2654
2655	/** @def AssertReleaseMsgRC
2656	* Asserts a iprt status code successful.
2657	*
2658	* On failure a custom message is printed and a breakpoint is hit.
2659	*
2660	* @param rc iprt status code.
2661	* @param msg printf argument list (in parenthesis).
2662	* @remark rc is referenced multiple times.
2663	*/
2664	#define AssertReleaseMsgRC(rc, msg) AssertReleaseMsg(RT_SUCCESS_NP(rc), msg)
2665
2666	/** @def AssertReleaseMsgRCReturn
2667	* Asserts a iprt status code successful.
2668	*
2669	* On failure a custom message is printed, a breakpoint is hit, and finally
2670	* returning from the function if the breakpoint is somehow ignored.
2671	*
2672	* @param rc iprt status code.
2673	* @param msg printf argument list (in parenthesis).
2674	* @param rcRet What is to be presented to return.
2675	* @remark rc is referenced multiple times.
2676	*/
2677	#define AssertReleaseMsgRCReturn(rc, msg, rcRet) AssertReleaseMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2678
2679	/** @def AssertReleaseMsgRCReturnVoid
2680	* Asserts a iprt status code successful.
2681	*
2682	* On failure a custom message is printed, a breakpoint is hit, and finally
2683	* returning from the function if the breakpoint is somehow ignored.
2684	*
2685	* @param rc iprt status code.
2686	* @param msg printf argument list (in parenthesis).
2687	* @remark rc is referenced multiple times.
2688	*/
2689	#define AssertReleaseMsgRCReturnVoid(rc, msg) AssertReleaseMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2690
2691	/** @def AssertReleaseMsgRCBreak
2692	* Asserts a iprt status code successful.
2693	*
2694	* On failure a custom message is printed, a breakpoint is hit, and finally
2695	* breaking the current status if the breakpoint is somehow ignored.
2696	*
2697	* @param rc iprt status code.
2698	* @param msg printf argument list (in parenthesis).
2699	* @remark rc is referenced multiple times.
2700	*/
2701	#define AssertReleaseMsgRCBreak(rc, msg) AssertReleaseMsgBreak(RT_SUCCESS(rc), msg)
2702
2703	/** @def AssertReleaseMsgRCBreakStmt
2704	* Asserts a iprt status code successful.
2705	*
2706	* On failure a custom message is printed, a breakpoint is hit, and finally
2707	* the break statement is issued if the breakpoint is somehow ignored.
2708	*
2709	* @param rc iprt status code.
2710	* @param msg printf argument list (in parenthesis).
2711	* @param stmt Statement to execute before break in case of a failed assertion.
2712	* @remark rc is referenced multiple times.
2713	*/
2714	#define AssertReleaseMsgRCBreakStmt(rc, msg, stmt) AssertReleaseMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2715
2716	/** @def AssertReleaseRCSuccess
2717	* Asserts that an iprt status code equals VINF_SUCCESS.
2718	*
2719	* On failure information about the error will be printed and a breakpoint hit.
2720	*
2721	* @param rc iprt status code.
2722	* @remark rc is referenced multiple times.
2723	*/
2724	#define AssertReleaseRCSuccess(rc) AssertReleaseMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2725
2726	/** @def AssertReleaseRCSuccessReturn
2727	* Asserts that an iprt status code equals VINF_SUCCESS.
2728	*
2729	* On failure information about the error will be printed, a breakpoint hit
2730	* and finally returning from the function if the breakpoint is somehow ignored.
2731	*
2732	* @param rc iprt status code.
2733	* @param rcRet What is to be presented to return.
2734	* @remark rc is referenced multiple times.
2735	*/
2736	#define AssertReleaseRCSuccessReturn(rc, rcRet) AssertReleaseMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2737
2738	/** @def AssertReleaseRCSuccessReturnVoid
2739	* Asserts that an iprt status code equals VINF_SUCCESS.
2740	*
2741	* On failure information about the error will be printed, a breakpoint hit
2742	* and finally returning from the function if the breakpoint is somehow ignored.
2743	*
2744	* @param rc iprt status code.
2745	* @remark rc is referenced multiple times.
2746	*/
2747	#define AssertReleaseRCSuccessReturnVoid(rc) AssertReleaseMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2748
2749	/** @def AssertReleaseRCSuccessBreak
2750	* Asserts that an iprt status code equals VINF_SUCCESS.
2751	*
2752	* On failure information about the error will be printed, a breakpoint hit
2753	* and finally breaking the current statement if the breakpoint is somehow ignored.
2754	*
2755	* @param rc iprt status code.
2756	* @remark rc is referenced multiple times.
2757	*/
2758	#define AssertReleaseRCSuccessBreak(rc) AssertReleaseMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2759
2760	/** @def AssertReleaseRCSuccessBreakStmt
2761	* Asserts that an iprt status code equals VINF_SUCCESS.
2762	*
2763	* On failure information about the error will be printed, a breakpoint hit
2764	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2765	*
2766	* @param rc iprt status code.
2767	* @param stmt Statement to execute before break in case of a failed assertion.
2768	* @remark rc is referenced multiple times.
2769	*/
2770	#define AssertReleaseRCSuccessBreakStmt(rc, stmt) AssertReleaseMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2771
2772
2773	/** @def AssertFatalRC
2774	* Asserts a iprt status code successful.
2775	*
2776	* On failure information about the error will be printed and a breakpoint hit.
2777	*
2778	* @param rc iprt status code.
2779	* @remark rc is referenced multiple times.
2780	*/
2781	#define AssertFatalRC(rc) AssertFatalMsgRC(rc, ("%Rra\n", (rc)))
2782
2783	/** @def AssertReleaseMsgRC
2784	* Asserts a iprt status code successful.
2785	*
2786	* On failure a custom message is printed and a breakpoint is hit.
2787	*
2788	* @param rc iprt status code.
2789	* @param msg printf argument list (in parenthesis).
2790	* @remark rc is referenced multiple times.
2791	*/
2792	#define AssertFatalMsgRC(rc, msg) AssertFatalMsg(RT_SUCCESS_NP(rc), msg)
2793
2794	/** @def AssertFatalRCSuccess
2795	* Asserts that an iprt status code equals VINF_SUCCESS.
2796	*
2797	* On failure information about the error will be printed and a breakpoint hit.
2798	*
2799	* @param rc iprt status code.
2800	* @remark rc is referenced multiple times.
2801	*/
2802	#define AssertFatalRCSuccess(rc) AssertFatalMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2803
2804
2805	/** @def AssertPtr
2806	* Asserts that a pointer is valid.
2807	*
2808	* @param pv The pointer.
2809	*/
2810	#define AssertPtr(pv) AssertMsg(RT_VALID_PTR(pv), ("%p\n", (pv)))
2811
2812	/** @def AssertPtrReturn
2813	* Asserts that a pointer is valid.
2814	*
2815	* @param pv The pointer.
2816	* @param rcRet What is to be presented to return.
2817	*/
2818	#define AssertPtrReturn(pv, rcRet) AssertMsgReturn(RT_VALID_PTR(pv), ("%p\n", (pv)), rcRet)
2819
2820	/** @def AssertPtrReturnVoid
2821	* Asserts that a pointer is valid.
2822	*
2823	* @param pv The pointer.
2824	*/
2825	#define AssertPtrReturnVoid(pv) AssertMsgReturnVoid(RT_VALID_PTR(pv), ("%p\n", (pv)))
2826
2827	/** @def AssertPtrReturnStmt
2828	* Asserts that a pointer is valid.
2829	*
2830	* @param pv The pointer.
2831	* @param stmt Statement to execute before returninig in case of a failed
2832	* assertion.
2833	* @param rcRet What is to be presented to return.
2834	*/
2835	#define AssertPtrReturnStmt(pv, stmt, rcRet) AssertMsgReturnStmt(RT_VALID_PTR(pv), ("%p\n", (pv)), stmt, rcRet)
2836
2837	/** @def AssertPtrReturnVoidStmt
2838	* Asserts that a pointer is valid.
2839	*
2840	* @param pv The pointer.
2841	* @param stmt Statement to execute before returninig in case of a failed
2842	* assertion.
2843	*/
2844	#define AssertPtrReturnVoidStmt(pv, stmt) AssertMsgReturnVoid(RT_VALID_PTR(pv), ("%p\n", (pv)), stmt)
2845
2846	/** @def AssertPtrBreak
2847	* Asserts that a pointer is valid.
2848	*
2849	* @param pv The pointer.
2850	*/
2851	#define AssertPtrBreak(pv) AssertMsgBreak(RT_VALID_PTR(pv), ("%p\n", (pv)))
2852
2853	/** @def AssertPtrBreakStmt
2854	* Asserts that a pointer is valid.
2855	*
2856	* @param pv The pointer.
2857	* @param stmt Statement to execute before break in case of a failed assertion.
2858	*/
2859	#define AssertPtrBreakStmt(pv, stmt) AssertMsgBreakStmt(RT_VALID_PTR(pv), ("%p\n", (pv)), stmt)
2860
2861	/** @def AssertPtrNull
2862	* Asserts that a pointer is valid or NULL.
2863	*
2864	* @param pv The pointer.
2865	*/
2866	#define AssertPtrNull(pv) AssertMsg(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2867
2868	/** @def AssertPtrNullReturn
2869	* Asserts that a pointer is valid or NULL.
2870	*
2871	* @param pv The pointer.
2872	* @param rcRet What is to be presented to return.
2873	*/
2874	#define AssertPtrNullReturn(pv, rcRet) AssertMsgReturn(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), rcRet)
2875
2876	/** @def AssertPtrNullReturnVoid
2877	* Asserts that a pointer is valid or NULL.
2878	*
2879	* @param pv The pointer.
2880	*/
2881	#define AssertPtrNullReturnVoid(pv) AssertMsgReturnVoid(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2882
2883	/** @def AssertPtrNullBreak
2884	* Asserts that a pointer is valid or NULL.
2885	*
2886	* @param pv The pointer.
2887	*/
2888	#define AssertPtrNullBreak(pv) AssertMsgBreak(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2889
2890	/** @def AssertPtrNullBreakStmt
2891	* Asserts that a pointer is valid or NULL.
2892	*
2893	* @param pv The pointer.
2894	* @param stmt Statement to execute before break in case of a failed assertion.
2895	*/
2896	#define AssertPtrNullBreakStmt(pv, stmt) AssertMsgBreakStmt(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), stmt)
2897
2898	/** @def AssertGCPhys32
2899	* Asserts that the high dword of a physical address is zero
2900	*
2901	* @param GCPhys The address (RTGCPHYS).
2902	*/
2903	#define AssertGCPhys32(GCPhys) AssertMsg(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))
2904
2905	/** @def AssertGCPtr32
2906	* Asserts that the high dword of a physical address is zero
2907	*
2908	* @param GCPtr The address (RTGCPTR).
2909	*/
2910	#if GC_ARCH_BITS == 32
2911	# define AssertGCPtr32(GCPtr) do { } while (0)
2912	#else
2913	# define AssertGCPtr32(GCPtr) AssertMsg(!((GCPtr) & UINT64_C(0xffffffff00000000)), ("%RGv\n", GCPtr))
2914	#endif
2915
2916	/** @def AssertForEach
2917	* Equivalent to Assert for each value of the variable from the starting
2918	* value to the finishing one.
2919	*
2920	* @param var Name of the counter variable.
2921	* @param vartype Type of the counter variable.
2922	* @param first Lowest inclusive value of the counter variable.
2923	* This must be free from side effects.
2924	* @param end Highest exclusive value of the counter variable.
2925	* This must be free from side effects.
2926	* @param expr Expression which should be true for each value of @a var.
2927	*/
2928	#define AssertForEach(var, vartype, first, end, expr) \
2929	do { \
2930	vartype var; \
2931	Assert((first) == (first) && (end) == (end)); /* partial check for side effects */ \
2932	for (var = (first); var < (end); var++) \
2933	AssertMsg(expr, ("%s = %#RX64 (%RI64)", #var, (uint64_t)var, (int64_t)var)); \
2934	} while (0)
2935
2936	#ifdef RT_OS_WINDOWS
2937
2938	/** @def AssertNtStatus
2939	* Asserts that the NT_SUCCESS() returns true for the given NTSTATUS value.
2940	*
2941	* @param a_rcNt The NTSTATUS to check. Will be evaluated twice and
2942	* subjected to NOREF().
2943	* @sa AssertRC()
2944	*/
2945	# define AssertNtStatus(a_rcNt) \
2946	do { AssertMsg(NT_SUCCESS(a_rcNt), ("%#x\n", (a_rcNt))); NOREF(a_rcNt); } while (0)
2947
2948	/** @def AssertNtStatusSuccess
2949	* Asserts that the given NTSTATUS value equals STATUS_SUCCESS.
2950	*
2951	* @param a_rcNt The NTSTATUS to check. Will be evaluated twice and
2952	* subjected to NOREF().
2953	* @sa AssertRCSuccess()
2954	*/
2955	# define AssertNtStatusSuccess(a_rcNt) \
2956	do { AssertMsg((a_rcNt) == STATUS_SUCCESS, ("%#x\n", (a_rcNt))); NOREF(a_rcNt); } while (0)
2957
2958	#endif /* RT_OS_WINDOWS */
2959
2960	/** @} */
2961
2962	/** @} */
2963
2964	#endif /* !IPRT_INCLUDED_assert_h */
2965

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

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

Download in other formats: