VirtualBox

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

Last change on this file since 660 was 1, checked in by vboxsync, 55 years ago

import
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 33.3 KB
Line 
1/** @file
2 * InnoTek Portable Runtime - Assertions.
3 */
4
5/*
6 * Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
12 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
13 * distribution. VirtualBox OSE is distributed in the hope that it will
14 * be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * If you received this file as part of a commercial VirtualBox
17 * distribution, then only the terms of your commercial VirtualBox
18 * license agreement apply instead of the previous paragraph.
19 */
20
21#ifndef __iprt_assert_h__
22#define __iprt_assert_h__
23
24#include <iprt/cdefs.h>
25#include <iprt/types.h>
26
27/** @defgroup grp_rt_assert Assert - Assertions
28 * @ingroup grp_rt
29 * @{
30 */
31
32
33/** @def AssertBreakpoint()
34 * Assertion Breakpoint.
35 *
36 * @remark In the gnu world we add a nop instruction after the int3 to
37 * force gdb to remain at the int3 source line.
38 * @remark The L4 kernel will try make sense of the breakpoint, thus the jmp.
39 */
40#ifdef RT_STRICT
41# ifdef __GNUC__
42# ifndef __L4ENV__
43# define AssertBreakpoint() do { __asm__ __volatile__ ("int3\n\tnop"); } while (0)
44# else
45# define AssertBreakpoint() do { __asm__ __volatile__ ("int3; jmp 1f; 1:"); } while (0)
46# endif
47# else
48# ifdef IN_RING0
49# define AssertBreakpoint() do { if (RTAssertDoBreakpoint()) __debugbreak(); } while (0)
50# else
51# define AssertBreakpoint() __debugbreak()
52# endif
53# endif
54#else
55# define AssertBreakpoint() do { } while (0)
56#endif
57
58/**
59 * RTASSERTTYPE is the type the AssertCompile() macro redefines.
60 * It has no other function and shouldn't be used.
61 * Visual C++ uses this.
62 */
63typedef int RTASSERTTYPE[1];
64
65/**
66 * RTASSERTVAR is the type the AssertCompile() macro redefines.
67 * It has no other function and shouldn't be used.
68 * GCC uses this.
69 */
70extern int RTASSERTVAR[1];
71
72/** @def AssertCompile
73 * Asserts that a compile-time expression is true. If it's not break the build.
74 * @param expr Expression which should be true.
75 */
76#ifdef __GNUC__
77# define AssertCompile(expr) extern int RTASSERTVAR[(expr) ? 1 : 0] __attribute__((unused))
78#else
79# define AssertCompile(expr) typedef int RTASSERTTYPE[(expr) ? 1 : 0]
80#endif
81
82/** @def AssertCompileSize
83 * Asserts a size at compile.
84 * @param type The type.
85 * @param size The expected type size.
86 */
87#define AssertCompileSize(type, size) \
88 AssertCompile(sizeof(type) == (size))
89
90/** @def AssertCompileSizeAlignment
91 * Asserts a size alignment at compile.
92 * @param type The type.
93 * @param align The size alignment to assert.
94 */
95#define AssertCompileSizeAlignment(type, align) \
96 AssertCompile(!(sizeof(type) & ((align) - 1)))
97
98/** @def AssertCompileMemberAlignment
99 * Asserts a member offset alignment at compile.
100 * @param type The type.
101 * @param member The member.
102 * @param align The member offset alignment to assert.
103 */
104#define AssertCompileMemberAlignment(type, member, align) \
105 AssertCompile(!(RT_OFFSETOF(type, member) & ((align) - 1)))
106
107/** @def AssertCompileMemberSize
108 * Asserts a member offset alignment at compile.
109 * @param type The type.
110 * @param member The member.
111 * @param size The member size to assert.
112 */
113#define AssertCompileMemberSize(type, member, size) \
114 AssertCompile(RT_SIZEOFMEMB(type, member) == (size))
115
116/** @def AssertCompileMemberSizeAlignment
117 * Asserts a member size alignment at compile.
118 * @param type The type.
119 * @param member The member.
120 * @param align The member size alignment to assert.
121 */
122#define AssertCompileMemberSizeAlignment(type, member, align) \
123 AssertCompile(!(RT_SIZEOFMEMB(type, member) & ((align) - 1)))
124
125
126/** @def Assert
127 * Assert that an expression is true. If it's not hit breakpoint.
128 * @param expr Expression which should be true.
129 */
130#ifdef RT_STRICT
131# define Assert(expr) \
132 do { \
133 if (RT_UNLIKELY(!(expr))) \
134 { \
135 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
136 AssertBreakpoint(); \
137 } \
138 } while (0)
139#else
140# define Assert(expr) do { } while (0)
141#endif
142
143
144/** @def AssertReturn
145 * Assert that an expression is true and returns if it isn't.
146 * In RT_STRICT mode it will hit a breakpoint before returning.
147 *
148 * @param expr Expression which should be true.
149 * @param rc What is to be presented to return.
150 */
151#ifdef RT_STRICT
152# define AssertReturn(expr, rc) \
153 do { \
154 if (RT_UNLIKELY(!(expr))) \
155 { \
156 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
157 AssertBreakpoint(); \
158 return (rc); \
159 } \
160 } while (0)
161#else
162# define AssertReturn(expr, rc) \
163 do { \
164 if (RT_UNLIKELY(!(expr))) \
165 return (rc); \
166 } while (0)
167#endif
168
169/** @def AssertReturnVoid
170 * Assert that an expression is true and returns if it isn't.
171 * In RT_STRICT mode it will hit a breakpoint before returning.
172 *
173 * @param expr Expression which should be true.
174 */
175#ifdef RT_STRICT
176# define AssertReturnVoid(expr) \
177 do { \
178 if (RT_UNLIKELY(!(expr))) \
179 { \
180 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
181 AssertBreakpoint(); \
182 return; \
183 } \
184 } while (0)
185#else
186# define AssertReturnVoid(expr) \
187 do { \
188 if (RT_UNLIKELY(!(expr))) \
189 return; \
190 } while (0)
191#endif
192
193
194/** @def AssertBreak
195 * Assert that an expression is true and breaks if it isn't.
196 * In RT_STRICT mode it will hit a breakpoint before doing break.
197 *
198 * @param expr Expression which should be true.
199 * @param stmt Statement to execute before break in case of a failed assertion.
200 */
201#ifdef RT_STRICT
202# define AssertBreak(expr, stmt) \
203 if (RT_UNLIKELY(!(expr))) { \
204 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
205 AssertBreakpoint(); \
206 stmt; \
207 break; \
208 } else do {} while (0)
209#else
210# define AssertBreak(expr, stmt) \
211 if (RT_UNLIKELY(!(expr))) { \
212 stmt; \
213 break; \
214 } else do {} while (0)
215#endif
216
217
218/** @def AssertMsg
219 * Assert that an expression is true. If it's not print message and hit breakpoint.
220 * @param expr Expression which should be true.
221 * @param a printf argument list (in parenthesis).
222 */
223#ifdef RT_STRICT
224# define AssertMsg(expr, a) \
225 do { \
226 if (RT_UNLIKELY(!(expr))) \
227 { \
228 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
229 AssertMsg2 a; \
230 AssertBreakpoint(); \
231 } \
232 } while (0)
233#else
234# define AssertMsg(expr, a) do { } while (0)
235#endif
236
237/** @def AssertMsgReturn
238 * Assert that an expression is true and returns if it isn't.
239 * In RT_STRICT mode it will hit a breakpoint before returning.
240 *
241 * @param expr Expression which should be true.
242 * @param a printf argument list (in parenthesis).
243 * @param rc What is to be presented to return.
244 */
245#ifdef RT_STRICT
246# define AssertMsgReturn(expr, a, rc) \
247 do { \
248 if (RT_UNLIKELY(!(expr))) \
249 { \
250 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
251 AssertMsg2 a; \
252 AssertBreakpoint(); \
253 return (rc); \
254 } \
255 } while (0)
256#else
257# define AssertMsgReturn(expr, a, rc) \
258 do { \
259 if (RT_UNLIKELY(!(expr))) \
260 return (rc); \
261 } while (0)
262#endif
263
264/** @def AssertMsgReturnVoid
265 * Assert that an expression is true and returns if it isn't.
266 * In RT_STRICT mode it will hit a breakpoint before returning.
267 *
268 * @param expr Expression which should be true.
269 * @param a printf argument list (in parenthesis).
270 */
271#ifdef RT_STRICT
272# define AssertMsgReturnVoid(expr, a) \
273 do { \
274 if (RT_UNLIKELY(!(expr))) \
275 { \
276 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
277 AssertMsg2 a; \
278 AssertBreakpoint(); \
279 return; \
280 } \
281 } while (0)
282#else
283# define AssertMsgReturnVoid(expr, a) \
284 do { \
285 if (RT_UNLIKELY(!(expr))) \
286 return; \
287 } while (0)
288#endif
289
290
291/** @def AssertMsgBreak
292 * Assert that an expression is true and breaks if it isn't.
293 * In RT_STRICT mode it will hit a breakpoint before doing break.
294 *
295 * @param expr Expression which should be true.
296 * @param a printf argument list (in parenthesis).
297 * @param stmt Statement to execute before break in case of a failed assertion.
298 */
299#ifdef RT_STRICT
300# define AssertMsgBreak(expr, a, stmt) \
301 if (RT_UNLIKELY(!(expr))) { \
302 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
303 AssertMsg2 a; \
304 AssertBreakpoint(); \
305 stmt; \
306 break; \
307 } else do {} while (0)
308#else
309# define AssertMsgBreak(expr, a, stmt) \
310 if (RT_UNLIKELY(!(expr))) { \
311 stmt; \
312 break; \
313 } else do {} while (0)
314#endif
315
316
317/** @def AssertFailed
318 * An assertion failed hit breakpoint.
319 */
320#ifdef RT_STRICT
321# define AssertFailed() \
322 do { \
323 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
324 AssertBreakpoint(); \
325 } while (0)
326#else
327# define AssertFailed() do { } while (0)
328#endif
329
330/** @def AssertFailedReturn
331 * An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
332 *
333 * @param rc The rc to return.
334 */
335#ifdef RT_STRICT
336# define AssertFailedReturn(rc) \
337 do { \
338 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
339 AssertBreakpoint(); \
340 return (rc); \
341 } while (0)
342#else
343# define AssertFailedReturn(rc) \
344 do { \
345 return (rc); \
346 } while (0)
347#endif
348
349/** @def AssertFailedReturnVoid
350 * An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
351 */
352#ifdef RT_STRICT
353# define AssertFailedReturnVoid() \
354 do { \
355 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
356 AssertBreakpoint(); \
357 return; \
358 } while (0)
359#else
360# define AssertFailedReturnVoid() \
361 do { \
362 return; \
363 } while (0)
364#endif
365
366
367/** @def AssertFailedBreak
368 * An assertion failed, hit breakpoint (RT_STRICT mode only), execute
369 * the given statement and break.
370 *
371 * @param stmt Statement to execute before break.
372 */
373#ifdef RT_STRICT
374# define AssertFailedBreak(stmt) \
375 if (1) { \
376 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
377 AssertBreakpoint(); \
378 stmt; \
379 break; \
380 } else do {} while (0)
381#else
382# define AssertFailedBreak(stmt) \
383 if (1) { \
384 stmt; \
385 break; \
386 } else do {} while (0)
387#endif
388
389
390/** @def AssertMsgFailed
391 * An assertion failed print a message and a hit breakpoint.
392 *
393 * @param a printf argument list (in parenthesis).
394 */
395#ifdef RT_STRICT
396# define AssertMsgFailed(a) \
397 do { \
398 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
399 AssertMsg2 a; \
400 AssertBreakpoint(); \
401 } while (0)
402#else
403# define AssertMsgFailed(a) do { } while (0)
404#endif
405
406/** @def AssertMsgFailedReturn
407 * An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
408 *
409 * @param a printf argument list (in parenthesis).
410 * @param rc What is to be presented to return.
411 */
412#ifdef RT_STRICT
413# define AssertMsgFailedReturn(a, rc) \
414 do { \
415 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
416 AssertMsg2 a; \
417 AssertBreakpoint(); \
418 return (rc); \
419 } while (0)
420#else
421# define AssertMsgFailedReturn(a, rc) \
422 do { \
423 return (rc); \
424 } while (0)
425#endif
426
427/** @def AssertMsgFailedReturnVoid
428 * An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
429 *
430 * @param a printf argument list (in parenthesis).
431 */
432#ifdef RT_STRICT
433# define AssertMsgFailedReturnVoid(a) \
434 do { \
435 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
436 AssertMsg2 a; \
437 AssertBreakpoint(); \
438 return; \
439 } while (0)
440#else
441# define AssertMsgFailedReturnVoid(a) \
442 do { \
443 return; \
444 } while (0)
445#endif
446
447
448/** @def AssertMsgFailedBreak
449 * An assertion failed, hit breakpoint (RT_STRICT mode only), execute
450 * the given statement and break.
451 *
452 * @param a printf argument list (in parenthesis).
453 * @param stmt Statement to execute before break.
454 */
455#ifdef RT_STRICT
456# define AssertMsgFailedBreak(a, stmt) \
457 if (1) { \
458 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
459 AssertMsg2 a; \
460 AssertBreakpoint(); \
461 stmt; \
462 break; \
463 } else do {} while (0)
464#else
465# define AssertMsgFailedBreak(a, stmt) \
466 if (1) { \
467 stmt; \
468 break; \
469 } else do {} while (0)
470#endif
471
472
473/** @def AssertReleaseBreakpoint()
474 * Assertion Breakpoint.
475 *
476 * @remark In the gnu world we add a nop instruction after the int3 to
477 * force gdb to remain at the int3 source line.
478 * @remark The L4 kernel will try make sense of the breakpoint, thus the jmp.
479 */
480#ifdef __GNUC__
481# ifndef __L4ENV__
482# define AssertReleaseBreakpoint() do { __asm__ __volatile__ ("int3\n\tnop"); } while (0)
483# else
484# define AssertReleaseBreakpoint() do { __asm__ __volatile__ ("int3; jmp 1f; 1:"); } while (0)
485# endif
486#else
487# define AssertReleaseBreakpoint() __debugbreak()
488#endif
489
490
491/** @def AssertRelease
492 * Assert that an expression is true. If it's not hit a breakpoint.
493 *
494 * @param expr Expression which should be true.
495 */
496#define AssertRelease(expr) \
497 do { \
498 if (RT_UNLIKELY(!(expr))) \
499 { \
500 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
501 AssertReleaseBreakpoint(); \
502 } \
503 } while (0)
504
505/** @def AssertReleaseReturn
506 * Assert that an expression is true, hit a breakpoing and return if it isn't.
507 *
508 * @param expr Expression which should be true.
509 * @param rc What is to be presented to return.
510 */
511#define AssertReleaseReturn(expr, rc) \
512 do { \
513 if (RT_UNLIKELY(!(expr))) \
514 { \
515 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
516 AssertReleaseBreakpoint(); \
517 return (rc); \
518 } \
519 } while (0)
520
521/** @def AssertReleaseReturnVoid
522 * Assert that an expression is true, hit a breakpoing and return if it isn't.
523 *
524 * @param expr Expression which should be true.
525 */
526#define AssertReleaseReturnVoid(expr) \
527 do { \
528 if (RT_UNLIKELY(!(expr))) \
529 { \
530 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
531 AssertReleaseBreakpoint(); \
532 return; \
533 } \
534 } while (0)
535
536
537/** @def AssertReleaseBreak
538 * Assert that an expression is true, hit a breakpoing and break if it isn't.
539 *
540 * @param expr Expression which should be true.
541 * @param stmt Statement to execute before break in case of a failed assertion.
542 */
543#define AssertReleaseBreak(expr, stmt) \
544 if (RT_UNLIKELY(!(expr))) { \
545 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
546 AssertReleaseBreakpoint(); \
547 stmt; \
548 break; \
549 } else do {} while (0)
550
551
552
553/** @def AssertReleaseMsg
554 * Assert that an expression is true, print the message and hit a breakpoint if it isn't.
555 *
556 * @param expr Expression which should be true.
557 * @param a printf argument list (in parenthesis).
558 */
559#define AssertReleaseMsg(expr, a) \
560 do { \
561 if (RT_UNLIKELY(!(expr))) \
562 { \
563 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
564 AssertMsg2 a; \
565 AssertReleaseBreakpoint(); \
566 } \
567 } while (0)
568
569/** @def AssertReleaseMsgReturn
570 * Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
571 *
572 * @param expr Expression which should be true.
573 * @param a printf argument list (in parenthesis).
574 * @param rc What is to be presented to return.
575 */
576#define AssertReleaseMsgReturn(expr, a, rc) \
577 do { \
578 if (RT_UNLIKELY(!(expr))) \
579 { \
580 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
581 AssertMsg2 a; \
582 AssertReleaseBreakpoint(); \
583 return (rc); \
584 } \
585 } while (0)
586
587/** @def AssertReleaseMsgReturn
588 * Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
589 *
590 * @param expr Expression which should be true.
591 * @param a printf argument list (in parenthesis).
592 */
593#define AssertReleaseMsgReturnVoid(expr, a) \
594 do { \
595 if (RT_UNLIKELY(!(expr))) \
596 { \
597 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
598 AssertMsg2 a; \
599 AssertReleaseBreakpoint(); \
600 return; \
601 } \
602 } while (0)
603
604
605/** @def AssertReleaseMsgBreak
606 * Assert that an expression is true, print the message and hit a breakpoing and break if it isn't.
607 *
608 * @param expr Expression which should be true.
609 * @param a printf argument list (in parenthesis).
610 * @param stmt Statement to execute before break in case of a failed assertion.
611 */
612#define AssertReleaseMsgBreak(expr, a, stmt) \
613 if (RT_UNLIKELY(!(expr))) { \
614 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
615 AssertMsg2 a; \
616 AssertReleaseBreakpoint(); \
617 stmt; \
618 break; \
619 } else do {} while (0)
620
621
622/** @def AssertReleaseFailed
623 * An assertion failed, hit a breakpoint.
624 */
625#define AssertReleaseFailed() \
626 do { \
627 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
628 AssertReleaseBreakpoint(); \
629 } while (0)
630
631/** @def AssertReleaseFailedReturn
632 * An assertion failed, hit a breakpoint and return.
633 *
634 * @param rc What is to be presented to return.
635 */
636#define AssertReleaseFailedReturn(rc) \
637 do { \
638 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
639 AssertReleaseBreakpoint(); \
640 return (rc); \
641 } while (0)
642
643/** @def AssertReleaseFailedReturn
644 * An assertion failed, hit a breakpoint and return.
645 */
646#define AssertReleaseFailedReturnVoid() \
647 do { \
648 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
649 AssertReleaseBreakpoint(); \
650 return; \
651 } while (0)
652
653
654/** @def AssertReleaseFailedBreak
655 * An assertion failed, hit a breakpoint and break.
656 *
657 * @param stmt Statement to execute before break.
658 */
659#define AssertReleaseFailedBreak(stmt) \
660 if (1) { \
661 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
662 AssertReleaseBreakpoint(); \
663 stmt; \
664 break; \
665 } else do {} while (0)
666
667
668/** @def AssertReleaseMsgFailed
669 * An assertion failed, print a message and hit a breakpoint.
670 *
671 * @param a printf argument list (in parenthesis).
672 */
673#define AssertReleaseMsgFailed(a) \
674 do { \
675 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
676 AssertMsg2 a; \
677 AssertReleaseBreakpoint(); \
678 } while (0)
679
680/** @def AssertReleaseMsgFailedReturn
681 * An assertion failed, print a message, hit a breakpoint and return.
682 *
683 * @param a printf argument list (in parenthesis).
684 * @param rc What is to be presented to return.
685 */
686#define AssertReleaseMsgFailedReturn(a, rc) \
687 do { \
688 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
689 AssertMsg2 a; \
690 AssertReleaseBreakpoint(); \
691 return (rc); \
692 } while (0)
693
694/** @def AssertReleaseMsgFailedReturnVoid
695 * An assertion failed, print a message, hit a breakpoint and return.
696 *
697 * @param a printf argument list (in parenthesis).
698 */
699#define AssertReleaseMsgFailedReturnVoid(a) \
700 do { \
701 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
702 AssertMsg2 a; \
703 AssertReleaseBreakpoint(); \
704 return; \
705 } while (0)
706
707
708/** @def AssertReleaseMsgFailedBreak
709 * An assertion failed, print a message, hit a breakpoint and break.
710 *
711 * @param a printf argument list (in parenthesis).
712 * @param stmt Statement to execute before break.
713 */
714#define AssertReleaseMsgFailedBreak(a, stmt) \
715 if (1) { \
716 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
717 AssertMsg2 a; \
718 AssertReleaseBreakpoint(); \
719 stmt; \
720 break; \
721 } else do {} while (0)
722
723
724
725/** @def AssertFatal
726 * Assert that an expression is true. If it's not hit a breakpoint (for ever).
727 *
728 * @param expr Expression which should be true.
729 */
730#define AssertFatal(expr) \
731 do { \
732 if (RT_UNLIKELY(!(expr))) \
733 for (;;) \
734 { \
735 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
736 AssertReleaseBreakpoint(); \
737 } \
738 } while (0)
739
740/** @def AssertFatalMsg
741 * Assert that an expression is true, print the message and hit a breakpoint (for ever) if it isn't.
742 *
743 * @param expr Expression which should be true.
744 * @param a printf argument list (in parenthesis).
745 */
746#define AssertFatalMsg(expr, a) \
747 do { \
748 if (RT_UNLIKELY(!(expr))) \
749 for (;;) \
750 { \
751 AssertMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
752 AssertMsg2 a; \
753 AssertReleaseBreakpoint(); \
754 } \
755 } while (0)
756
757/** @def AssertFatalFailed
758 * An assertion failed, hit a breakpoint (for ever).
759 */
760#define AssertFatalFailed() \
761 do { \
762 for (;;) \
763 { \
764 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
765 AssertReleaseBreakpoint(); \
766 } \
767 } while (0)
768
769/** @def AssertFatalMsgFailed
770 * An assertion failed, print a message and hit a breakpoint (for ever).
771 *
772 * @param a printf argument list (in parenthesis).
773 */
774#define AssertFatalMsgFailed(a) \
775 do { \
776 for (;;) \
777 { \
778 AssertMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
779 AssertMsg2 a; \
780 AssertReleaseBreakpoint(); \
781 } \
782 } while (0)
783
784
785/** @def AssertRC
786 * Asserts a iprt status code successful.
787 *
788 * On failure it will print info about the rc and hit a breakpoint.
789 *
790 * @param rc iprt status code.
791 * @remark rc is references multiple times. In release mode is NOREF()'ed.
792 */
793#define AssertRC(rc) AssertMsgRC(rc, ("%Vra\n", (rc)))
794
795/** @def AssertRCReturn
796 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
797 *
798 * @param rc iprt status code.
799 * @param rcRet What is to be presented to return.
800 * @remark rc is references multiple times. In release mode is NOREF()'ed.
801 */
802#define AssertRCReturn(rc, rcRet) AssertMsgRCReturn(rc, ("%Vra\n", (rc)), rcRet)
803
804/** @def AssertRCBreak
805 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
806 *
807 * @param rc iprt status code.
808 * @param stmt Statement to execute before break in case of a failed assertion.
809 * @remark rc is references multiple times. In release mode is NOREF()'ed.
810 */
811#define AssertRCBreak(rc, stmt) AssertMsgRCBreak(rc, ("%Vra\n", (rc)), stmt)
812
813/** @def AssertMsgRC
814 * Asserts a iprt status code successful.
815 *
816 * It prints a custom message and hits a breakpoint on FAILURE.
817 *
818 * @param rc iprt status code.
819 * @param msg printf argument list (in parenthesis).
820 * @remark rc is references multiple times. In release mode is NOREF()'ed.
821 */
822#define AssertMsgRC(rc, msg) \
823 do { AssertMsg(RT_SUCCESS(rc), msg); NOREF(rc); } while (0)
824
825/** @def AssertMsgRCReturn
826 * Asserts a iprt status code successful and if it's not return the specified status code.
827 *
828 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
829 *
830 * @param rc iprt status code.
831 * @param msg printf argument list (in parenthesis).
832 * @param rcRet What is to be presented to return.
833 * @remark rc is references multiple times. In release mode is NOREF()'ed.
834 */
835#define AssertMsgRCReturn(rc, msg, rcRet) \
836 do { AssertMsgReturn(RT_SUCCESS(rc), msg, rcRet); NOREF(rc); } while (0)
837
838/** @def AssertMsgRCBreak
839 * Asserts a iprt status code successful and break if it's not.
840 *
841 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
842 *
843 * @param rc iprt status code.
844 * @param msg printf argument list (in parenthesis).
845 * @param stmt Statement to execute before break in case of a failed assertion.
846 * @remark rc is references multiple times. In release mode is NOREF()'ed.
847 */
848#define AssertMsgRCBreak(rc, msg, stmt) \
849 do { AssertMsgBreak(RT_SUCCESS(rc), msg, stmt); NOREF(rc); } while (0)
850
851/** @def AssertRCSuccess
852 * Asserts an iprt status code equals VINF_SUCCESS.
853 *
854 * On failure it will print info about the rc and hit a breakpoint.
855 *
856 * @param rc iprt status code.
857 * @remark rc is references multiple times. In release mode is NOREF()'ed.
858 */
859#define AssertRCSuccess(rc) AssertMsg((rc) == VINF_SUCCESS, ("%Vra\n", (rc)))
860
861/** @def AssertRCSuccessReturn
862 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
863 *
864 * @param rc iprt status code.
865 * @param rcRet What is to be presented to return.
866 * @remark rc is references multiple times. In release mode is NOREF()'ed.
867 */
868#define AssertRCSuccessReturn(rc, rcRet) AssertMsgReturn((rc) == VINF_SUCCESS, ("%Vra\n", (rc)), rcRet)
869
870/** @def AssertRCSuccessBreak
871 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
872 *
873 * @param rc iprt status code.
874 * @param stmt Statement to execute before break in case of a failed assertion.
875 * @remark rc is references multiple times. In release mode is NOREF()'ed.
876 */
877#define AssertRCSuccessBreak(rc, stmt) AssertMsgBreak((rc) == VINF_SUCCESS, ("%Vra\n", (rc)), stmt)
878
879
880/** @def AssertReleaseRC
881 * Asserts a iprt status code successful.
882 *
883 * On failure information about the error will be printed and a breakpoint hit.
884 *
885 * @param rc iprt status code.
886 * @remark rc is references multiple times.
887 */
888#define AssertReleaseRC(rc) AssertReleaseMsgRC(rc, ("%Vra\n", (rc)))
889
890/** @def AssertReleaseRCReturn
891 * Asserts a iprt status code successful, returning if it isn't.
892 *
893 * On failure information about the error will be printed, a breakpoint hit
894 * and finally returning from the function if the breakpoint is somehow ignored.
895 *
896 * @param rc iprt status code.
897 * @param rcRet What is to be presented to return.
898 * @remark rc is references multiple times.
899 */
900#define AssertReleaseRCReturn(rc, rcRet) AssertReleaseMsgRCReturn(rc, ("%Vra\n", (rc)), rcRet)
901
902/** @def AssertReleaseRCBreak
903 * Asserts a iprt status code successful, break if it isn't.
904 *
905 * On failure information about the error will be printed, a breakpoint hit
906 * and finally the break statement will be issued if the breakpoint is somehow ignored.
907 *
908 * @param rc iprt status code.
909 * @param stmt Statement to execute before break in case of a failed assertion.
910 * @remark rc is references multiple times.
911 */
912#define AssertReleaseRCBreak(rc, stmt) AssertReleaseMsgRCBreak(rc, ("%Vra\n", (rc)), stmt)
913
914/** @def AssertReleaseMsgRC
915 * Asserts a iprt status code successful.
916 *
917 * On failure a custom message is printed and a breakpoint is hit.
918 *
919 * @param rc iprt status code.
920 * @param msg printf argument list (in parenthesis).
921 * @remark rc is references multiple times.
922 */
923#define AssertReleaseMsgRC(rc, msg) AssertReleaseMsg(RT_SUCCESS(rc), msg)
924
925/** @def AssertReleaseMsgRCReturn
926 * Asserts a iprt status code successful.
927 *
928 * On failure a custom message is printed, a breakpoint is hit, and finally
929 * returning from the function if the breakpoint is showhow ignored.
930 *
931 * @param rc iprt status code.
932 * @param msg printf argument list (in parenthesis).
933 * @param rcRet What is to be presented to return.
934 * @remark rc is references multiple times.
935 */
936#define AssertReleaseMsgRCReturn(rc, msg, rcRet) AssertReleaseMsgReturn(RT_SUCCESS(rc), msg, rcRet)
937
938/** @def AssertReleaseMsgRCBreak
939 * Asserts a iprt status code successful.
940 *
941 * On failure a custom message is printed, a breakpoint is hit, and finally
942 * the brean statement is issued if the breakpoint is showhow ignored.
943 *
944 * @param rc iprt status code.
945 * @param msg printf argument list (in parenthesis).
946 * @param stmt Statement to execute before break in case of a failed assertion.
947 * @remark rc is references multiple times.
948 */
949#define AssertReleaseMsgRCBreak(rc, msg, stmt) AssertReleaseMsgBreak(RT_SUCCESS(rc), msg, stmt)
950
951/** @def AssertReleaseRCSuccess
952 * Asserts that an iprt status code equals VINF_SUCCESS.
953 *
954 * On failure information about the error will be printed and a breakpoint hit.
955 *
956 * @param rc iprt status code.
957 * @remark rc is references multiple times.
958 */
959#define AssertReleaseRCSuccess(rc) AssertReleaseMsg((rc) == VINF_SUCCESS, ("%Vra\n", (rc)))
960
961/** @def AssertReleaseRCSuccessReturn
962 * Asserts that an iprt status code equals VINF_SUCCESS.
963 *
964 * On failure information about the error will be printed, a breakpoint hit
965 * and finally returning from the function if the breakpoint is somehow ignored.
966 *
967 * @param rc iprt status code.
968 * @param rcRet What is to be presented to return.
969 * @remark rc is references multiple times.
970 */
971#define AssertReleaseRCSuccessReturn(rc, rcRet) AssertReleaseMsgReturn((rc) == VINF_SUCCESS, ("%Vra\n", (rc)), rcRet)
972
973/** @def AssertReleaseRCSuccessBreak
974 * Asserts that an iprt status code equals VINF_SUCCESS.
975 *
976 * On failure information about the error will be printed, a breakpoint hit
977 * and finally the break statement will be issued if the breakpoint is somehow ignored.
978 *
979 * @param rc iprt status code.
980 * @param stmt Statement to execute before break in case of a failed assertion.
981 * @remark rc is references multiple times.
982 */
983#define AssertReleaseRCSuccessBreak(rc, stmt) AssertReleaseMsgBreak((rc) == VINF_SUCCESS, ("%Vra\n", (rc)), stmt)
984
985
986/** @def AssertFatalRC
987 * Asserts a iprt status code successful.
988 *
989 * On failure information about the error will be printed and a breakpoint hit.
990 *
991 * @param rc iprt status code.
992 * @remark rc is references multiple times.
993 */
994#define AssertFatalRC(rc) AssertFatalMsgRC(rc, ("%Vra\n", (rc)))
995
996/** @def AssertReleaseMsgRC
997 * Asserts a iprt status code successful.
998 *
999 * On failure a custom message is printed and a breakpoint is hit.
1000 *
1001 * @param rc iprt status code.
1002 * @param msg printf argument list (in parenthesis).
1003 * @remark rc is references multiple times.
1004 */
1005#define AssertFatalMsgRC(rc, msg) AssertFatalMsg(RT_SUCCESS(rc), msg)
1006
1007/** @def AssertFatalRCSuccess
1008 * Asserts that an iprt status code equals VINF_SUCCESS.
1009 *
1010 * On failure information about the error will be printed and a breakpoint hit.
1011 *
1012 * @param rc iprt status code.
1013 * @remark rc is references multiple times.
1014 */
1015#define AssertFatalRCSuccess(rc) AssertFatalMsg((rc) == VINF_SUCCESS, ("%Vra\n", (rc)))
1016
1017
1018/** @def AssertPtr
1019 * Asserts that a pointer is valid.
1020 *
1021 * @param pv The pointer.
1022 */
1023#define AssertPtr(pv) AssertMsg(VALID_PTR(pv), ("%p\n", (pv)))
1024
1025/** @def AssertPtrReturn
1026 * Asserts that a pointer is valid.
1027 *
1028 * @param pv The pointer.
1029 * @param rcRet What is to be presented to return.
1030 */
1031#define AssertPtrReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv), ("%p\n", (pv)), rcRet)
1032
1033/** @def AssertPtrBreak
1034 * Asserts that a pointer is valid.
1035 *
1036 * @param pv The pointer.
1037 * @param stmt Statement to execute before break in case of a failed assertion.
1038 */
1039#define AssertPtrBreak(pv, stmt) AssertMsgBreak(VALID_PTR(pv), ("%p\n", (pv)), stmt)
1040
1041/** @def AssertPtrNull
1042 * Asserts that a pointer is valid or NULL.
1043 *
1044 * @param pv The pointer.
1045 */
1046#define AssertPtrNull(pv) AssertMsg(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)))
1047
1048/** @def AssertPtrNullReturn
1049 * Asserts that a pointer is valid or NULL.
1050 *
1051 * @param pv The pointer.
1052 * @param rcRet What is to be presented to return.
1053 */
1054#define AssertPtrNullReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)), rcRet)
1055
1056/** @def AssertPtrNullBreak
1057 * Asserts that a pointer is valid or NULL.
1058 *
1059 * @param pv The pointer.
1060 * @param stmt Statement to execute before break in case of a failed assertion.
1061 */
1062#define AssertPtrNullBreak(pv, stmt) AssertMsgBreak(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)), stmt)
1063
1064
1065__BEGIN_DECLS
1066
1067/**
1068 * The 1st part of an assert message.
1069 *
1070 * @param pszExpr Expression. Can be NULL.
1071 * @param uLine Location line number.
1072 * @param pszFile Location file name.
1073 * @param pszFunction Location function name.
1074 * @remark This API exists in HC Ring-3 and GC.
1075 */
1076RTDECL(void) AssertMsg1(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
1077
1078/**
1079 * The 2nd (optional) part of an assert message.
1080 * @param pszFormat Printf like format string.
1081 * @param ... Arguments to that string.
1082 * @remark This API exists in HC Ring-3 and GC.
1083 */
1084RTDECL(void) AssertMsg2(const char *pszFormat, ...);
1085
1086/**
1087 * Check if we really want to hit a breakpoint.
1088 * Can jump back to ring-3 when the longjmp is armed.
1089 */
1090RTDECL(bool) RTAssertDoBreakpoint(void);
1091
1092/** The last assert message, 1st part. */
1093extern RTDATADECL(char) g_szRTAssertMsg1[1024];
1094/** The last assert message, 2nd part. */
1095extern RTDATADECL(char) g_szRTAssertMsg2[2048];
1096
1097__END_DECLS
1098
1099/** @} */
1100
1101#endif
1102
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