VirtualBox

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

Last change on this file since 29273 was 28800, checked in by vboxsync, 15 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette