VirtualBox

source: vbox/trunk/include/VBox/AssertGuest.h

Last change on this file was 98103, checked in by vboxsync, 16 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 59.3 KB
Line 
1/** @file
2 * VirtualBox - Guest input assertions.
3 */
4
5/*
6 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
7 *
8 * This file is part of VirtualBox base platform packages, as
9 * available from https://www.virtualbox.org.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation, in version 3 of the
14 * License.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, see <https://www.gnu.org/licenses>.
23 *
24 * The contents of this file may alternatively be used under the terms
25 * of the Common Development and Distribution License Version 1.0
26 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27 * in the VirtualBox distribution, in which case the provisions of the
28 * CDDL are applicable instead of those of the GPL.
29 *
30 * You may elect to license modified versions of this file under the
31 * terms and conditions of either the GPL or the CDDL or both.
32 *
33 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34 */
35
36#ifndef VBOX_INCLUDED_AssertGuest_h
37#define VBOX_INCLUDED_AssertGuest_h
38#ifndef RT_WITHOUT_PRAGMA_ONCE
39# pragma once
40#endif
41
42#include <VBox/cdefs.h>
43#include <iprt/assert.h>
44
45
46/** @defgroup grp_vbox_assert_guest VBox Guest Input Assertion Macros
47 * @{
48 */
49
50
51/** @name Guest input assertions
52 *
53 * These assertions will only trigger when VBOX_STRICT_GUEST is defined. When
54 * it is undefined they will all be no-ops and generate no code, unless they
55 * have other side effected (i.e. the _RETURN, _STMT, _BREAK variations).
56 *
57 * The assertions build on top of the functions in iprt/assert.h.
58 *
59 * @{
60 */
61
62
63/** @def ASSERT_GUEST_PANIC()
64 * If VBOX_STRICT_GUEST is defined this macro will invoke RTAssertDoPanic if
65 * RTAssertShouldPanic returns true. If VBOX_STRICT_GUEST isn't defined it won't
66 * do any thing.
67 */
68#if defined(VBOX_STRICT_GUEST) && !defined(VBOX_STRICT_GUEST_DONT_PANIC)
69# define ASSERT_GUEST_PANIC() do { if (RTAssertShouldPanic()) RTAssertDoPanic(); } while (0)
70#else
71# define ASSERT_GUEST_PANIC() do { } while (0)
72#endif
73
74/** Wrapper around RTAssertMsg1Weak that prefixes the expression. */
75#define ASSERT_GUEST_MSG1(szExpr, iLine, pszFile, pszFunction) \
76 RTAssertMsg1Weak("guest-input: " szExpr, iLine, pszFile, pszFunction)
77
78
79/** @def ASSERT_GUEST
80 * Assert that an expression is true. If false, hit breakpoint.
81 * @param a_Expr Expression which should be true.
82 */
83#ifdef VBOX_STRICT_GUEST
84# define ASSERT_GUEST(a_Expr) \
85 do { \
86 if (RT_LIKELY(!!(a_Expr))) \
87 { /* likely */ } \
88 else \
89 { \
90 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
91 ASSERT_GUEST_PANIC(); \
92 } \
93 } while (0)
94#else
95# define ASSERT_GUEST(a_Expr) do { } while (0)
96#endif
97
98
99/** @def ASSERT_GUEST_STMT
100 * Assert that an expression is true. If false, hit breakpoint and execute the
101 * statement.
102 * @param a_Expr Expression which should be true.
103 * @param a_Stmt Statement to execute on failure.
104 */
105#ifdef VBOX_STRICT_GUEST
106# define ASSERT_GUEST_STMT(a_Expr, a_Stmt) \
107 do { \
108 if (RT_LIKELY(!!(a_Expr))) \
109 { /* likely */ } \
110 else \
111 { \
112 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
113 ASSERT_GUEST_PANIC(); \
114 a_Stmt; \
115 } \
116 } while (0)
117#else
118# define ASSERT_GUEST_STMT(a_Expr, a_Stmt) \
119 do { \
120 if (RT_LIKELY(!!(a_Expr))) \
121 { /* likely */ } \
122 else \
123 { \
124 a_Stmt; \
125 } \
126 } while (0)
127#endif
128
129
130/** @def ASSERT_GUEST_RETURN
131 * Assert that an expression is true and returns if it isn't.
132 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
133 *
134 * @param a_Expr Expression which should be true.
135 * @param a_rc What is to be presented to return.
136 */
137#ifdef VBOX_STRICT_GUEST
138# define ASSERT_GUEST_RETURN(a_Expr, a_rc) \
139 do { \
140 if (RT_LIKELY(!!(a_Expr))) \
141 { /* likely */ } \
142 else \
143 { \
144 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
145 ASSERT_GUEST_PANIC(); \
146 return (a_rc); \
147 } \
148 } while (0)
149#else
150# define ASSERT_GUEST_RETURN(a_Expr, a_rc) \
151 do { \
152 if (RT_LIKELY(!!(a_Expr))) \
153 { /* likely */ } \
154 else \
155 return (a_rc); \
156 } while (0)
157#endif
158
159/** @def ASSERT_GUEST_STMT_RETURN
160 * Assert that an expression is true, if it isn't execute the given statement
161 * and return rc.
162 *
163 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before executing the statement and
164 * returning.
165 *
166 * @param a_Expr Expression which should be true.
167 * @param a_Stmt Statement to execute before returning on failure.
168 * @param a_rc What is to be presented to return.
169 */
170#ifdef VBOX_STRICT_GUEST
171# define ASSERT_GUEST_STMT_RETURN(a_Expr, a_Stmt, a_rc) \
172 do { \
173 if (RT_LIKELY(!!(a_Expr))) \
174 { /* likely */ } \
175 else \
176 { \
177 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
178 ASSERT_GUEST_PANIC(); \
179 a_Stmt; \
180 return (a_rc); \
181 } \
182 } while (0)
183#else
184# define ASSERT_GUEST_STMT_RETURN(a_Expr, a_Stmt, a_rc) \
185 do { \
186 if (RT_LIKELY(!!(a_Expr))) \
187 { /* likely */ } \
188 else \
189 { \
190 a_Stmt; \
191 return (a_rc); \
192 } \
193 } while (0)
194#endif
195
196/** @def ASSERT_GUEST_RETURN_VOID
197 * Assert that an expression is true and returns if it isn't.
198 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
199 *
200 * @param a_Expr Expression which should be true.
201 */
202#ifdef VBOX_STRICT_GUEST
203# define ASSERT_GUEST_RETURN_VOID(a_Expr) \
204 do { \
205 if (RT_LIKELY(!!(a_Expr))) \
206 { /* likely */ } \
207 else \
208 { \
209 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
210 ASSERT_GUEST_PANIC(); \
211 return; \
212 } \
213 } while (0)
214#else
215# define ASSERT_GUEST_RETURN_VOID(a_Expr) \
216 do { \
217 if (RT_LIKELY(!!(a_Expr))) \
218 { /* likely */ } \
219 else \
220 return; \
221 } while (0)
222#endif
223
224/** @def ASSERT_GUEST_STMT_RETURN_VOID
225 * Assert that an expression is true, if it isn't execute the given statement
226 * and return.
227 *
228 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
229 *
230 * @param a_Expr Expression which should be true.
231 * @param a_Stmt Statement to execute before returning on failure.
232 */
233#ifdef VBOX_STRICT_GUEST
234# define ASSERT_GUEST_STMT_RETURN_VOID(a_Expr, a_Stmt) \
235 do { \
236 if (RT_LIKELY(!!(a_Expr))) \
237 { /* likely */ } \
238 else \
239 { \
240 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
241 ASSERT_GUEST_PANIC(); \
242 a_Stmt; \
243 return; \
244 } \
245 } while (0)
246#else
247# define ASSERT_GUEST_STMT_RETURN_VOID(a_Expr, a_Stmt) \
248 do { \
249 if (RT_LIKELY(!!(a_Expr))) \
250 { /* likely */ } \
251 else \
252 { \
253 a_Stmt; \
254 return; \
255 } \
256 } while (0)
257#endif
258
259
260/** @def ASSERT_GUEST_BREAK
261 * Assert that an expression is true and breaks if it isn't.
262 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before breaking.
263 *
264 * @param a_Expr Expression which should be true.
265 */
266#ifdef VBOX_STRICT_GUEST
267# define ASSERT_GUEST_BREAK(a_Expr) \
268 if (RT_LIKELY(!!(a_Expr))) \
269 { /* likely */ } \
270 else if (1) \
271 { \
272 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
273 ASSERT_GUEST_PANIC(); \
274 break; \
275 } else \
276 break
277#else
278# define ASSERT_GUEST_BREAK(a_Expr) \
279 if (RT_LIKELY(!!(a_Expr))) \
280 { /* likely */ } \
281 else \
282 break
283#endif
284
285/** @def ASSERT_GUEST_CONTINUE
286 * Assert that an expression is true and continue if it isn't.
287 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before continuing.
288 *
289 * @param a_Expr Expression which should be true.
290 */
291#ifdef VBOX_STRICT_GUEST
292# define ASSERT_GUEST_CONTINUE(a_Expr) \
293 if (RT_LIKELY(!!(a_Expr))) \
294 { /* likely */ } \
295 else if (1) \
296 { \
297 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
298 ASSERT_GUEST_PANIC(); \
299 continue; \
300 } else do {} while (0)
301#else
302# define ASSERT_GUEST_CONTINUE(a_Expr) \
303 if (RT_LIKELY(!!(a_Expr))) \
304 { /* likely */ } \
305 else \
306 continue
307#endif
308
309/** @def ASSERT_GUEST_STMT_BREAK
310 * Assert that an expression is true and breaks if it isn't.
311 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before doing break.
312 *
313 * @param a_Expr Expression which should be true.
314 * @param a_Stmt Statement to execute before break in case of a failed assertion.
315 */
316#ifdef VBOX_STRICT_GUEST
317# define ASSERT_GUEST_STMT_BREAK(a_Expr, a_Stmt) \
318 if (RT_LIKELY(!!(a_Expr))) \
319 { /* likely */ } \
320 else if (1) \
321 { \
322 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
323 ASSERT_GUEST_PANIC(); \
324 a_Stmt; \
325 break; \
326 } else do {} while (0)
327#else
328# define ASSERT_GUEST_STMT_BREAK(a_Expr, a_Stmt) \
329 if (RT_LIKELY(!!(a_Expr))) \
330 { /* likely */ } \
331 else if (1) \
332 { \
333 a_Stmt; \
334 break; \
335 } else do {} while (0)
336#endif
337
338
339/** @def ASSERT_GUEST_MSG
340 * Assert that an expression is true. If it's not print message and hit breakpoint.
341 * @param a_Expr Expression which should be true.
342 * @param a printf argument list (in parenthesis).
343 */
344#ifdef VBOX_STRICT_GUEST
345# define ASSERT_GUEST_MSG(a_Expr, a) \
346 do { \
347 if (RT_LIKELY(!!(a_Expr))) \
348 { /* likely */ } \
349 else \
350 { \
351 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
352 RTAssertMsg2Weak a; \
353 ASSERT_GUEST_PANIC(); \
354 } \
355 } while (0)
356#else
357# define ASSERT_GUEST_MSG(a_Expr, a) do { } while (0)
358#endif
359
360/** @def ASSERT_GUEST_MSG_STMT
361 * Assert that an expression is true. If it's not print message and hit
362 * breakpoint and execute the statement.
363 *
364 * @param a_Expr Expression which should be true.
365 * @param a printf argument list (in parenthesis).
366 * @param a_Stmt Statement to execute in case of a failed assertion.
367 *
368 * @remarks The expression and statement will be evaluated in all build types.
369 */
370#ifdef VBOX_STRICT_GUEST
371# define ASSERT_GUEST_MSG_STMT(a_Expr, a, a_Stmt) \
372 do { \
373 if (RT_LIKELY(!!(a_Expr))) \
374 { /* likely */ } \
375 else \
376 { \
377 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
378 RTAssertMsg2Weak a; \
379 ASSERT_GUEST_PANIC(); \
380 a_Stmt; \
381 } \
382 } while (0)
383#else
384# define ASSERT_GUEST_MSG_STMT(a_Expr, a, a_Stmt) \
385 do { \
386 if (RT_LIKELY(!!(a_Expr))) \
387 { /* likely */ } \
388 else \
389 { \
390 a_Stmt; \
391 } \
392 } while (0)
393#endif
394
395/** @def ASSERT_GUEST_MSG_RETURN
396 * Assert that an expression is true and returns if it isn't.
397 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
398 *
399 * @param a_Expr Expression which should be true.
400 * @param a printf argument list (in parenthesis).
401 * @param a_rc What is to be presented to return.
402 */
403#ifdef VBOX_STRICT_GUEST
404# define ASSERT_GUEST_MSG_RETURN(a_Expr, a, a_rc) \
405 do { \
406 if (RT_LIKELY(!!(a_Expr))) \
407 { /* likely */ } \
408 else \
409 { \
410 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
411 RTAssertMsg2Weak a; \
412 ASSERT_GUEST_PANIC(); \
413 return (a_rc); \
414 } \
415 } while (0)
416#else
417# define ASSERT_GUEST_MSG_RETURN(a_Expr, a, a_rc) \
418 do { \
419 if (RT_LIKELY(!!(a_Expr))) \
420 { /* likely */ } \
421 else \
422 return (a_rc); \
423 } while (0)
424#endif
425
426/** @def ASSERT_GUEST_MSG_STMT_RETURN
427 * Assert that an expression is true, if it isn't execute the statement and
428 * return.
429 *
430 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
431 *
432 * @param a_Expr Expression which should be true.
433 * @param a printf argument list (in parenthesis).
434 * @param a_Stmt Statement to execute before returning in case of a failed
435 * assertion.
436 * @param a_rc What is to be presented to return.
437 */
438#ifdef VBOX_STRICT_GUEST
439# define ASSERT_GUEST_MSG_STMT_RETURN(a_Expr, a, a_Stmt, a_rc) \
440 do { \
441 if (RT_LIKELY(!!(a_Expr))) \
442 { /* likely */ } \
443 else \
444 { \
445 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
446 RTAssertMsg2Weak a; \
447 ASSERT_GUEST_PANIC(); \
448 a_Stmt; \
449 return (a_rc); \
450 } \
451 } while (0)
452#else
453# define ASSERT_GUEST_MSG_STMT_RETURN(a_Expr, a, a_Stmt, a_rc) \
454 do { \
455 if (RT_LIKELY(!!(a_Expr))) \
456 { /* likely */ } \
457 else \
458 { \
459 a_Stmt; \
460 return (a_rc); \
461 } \
462 } while (0)
463#endif
464
465/** @def ASSERT_GUEST_MSG_RETURN_VOID
466 * Assert that an expression is true and returns if it isn't.
467 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
468 *
469 * @param a_Expr Expression which should be true.
470 * @param a printf argument list (in parenthesis).
471 */
472#ifdef VBOX_STRICT_GUEST
473# define ASSERT_GUEST_MSG_RETURN_VOID(a_Expr, a) \
474 do { \
475 if (RT_LIKELY(!!(a_Expr))) \
476 { /* likely */ } \
477 else \
478 { \
479 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
480 RTAssertMsg2Weak a; \
481 ASSERT_GUEST_PANIC(); \
482 return; \
483 } \
484 } while (0)
485#else
486# define ASSERT_GUEST_MSG_RETURN_VOID(a_Expr, a) \
487 do { \
488 if (RT_LIKELY(!!(a_Expr))) \
489 { /* likely */ } \
490 else \
491 return; \
492 } while (0)
493#endif
494
495/** @def ASSERT_GUEST_MSG_STMT_RETURN_VOID
496 * Assert that an expression is true, if it isn't execute the statement and
497 * return.
498 *
499 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
500 *
501 * @param a_Expr Expression which should be true.
502 * @param a printf argument list (in parenthesis).
503 * @param a_Stmt Statement to execute before return in case of a failed assertion.
504 */
505#ifdef VBOX_STRICT_GUEST
506# define ASSERT_GUEST_MSG_STMT_RETURN_VOID(a_Expr, a, a_Stmt) \
507 do { \
508 if (RT_LIKELY(!!(a_Expr))) \
509 { /* likely */ } \
510 else \
511 { \
512 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
513 RTAssertMsg2Weak a; \
514 ASSERT_GUEST_PANIC(); \
515 a_Stmt; \
516 return; \
517 } \
518 } while (0)
519#else
520# define ASSERT_GUEST_MSG_STMT_RETURN_VOID(a_Expr, a, a_Stmt) \
521 do { \
522 if (RT_LIKELY(!!(a_Expr))) \
523 { /* likely */ } \
524 else \
525 { \
526 a_Stmt; \
527 return; \
528 } \
529 } while (0)
530#endif
531
532
533/** @def ASSERT_GUEST_MSG_BREAK
534 * Assert that an expression is true and breaks if it isn't.
535 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
536 *
537 * @param a_Expr Expression which should be true.
538 * @param a printf argument list (in parenthesis).
539 */
540#ifdef VBOX_STRICT_GUEST
541# define ASSERT_GUEST_MSG_BREAK(a_Expr, a) \
542 if (RT_LIKELY(!!(a_Expr))) \
543 { /* likely */ } \
544 else if (1) \
545 { \
546 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
547 RTAssertMsg2Weak a; \
548 ASSERT_GUEST_PANIC(); \
549 break; \
550 } else \
551 break
552#else
553# define ASSERT_GUEST_MSG_BREAK(a_Expr, a) \
554 if (RT_LIKELY(!!(a_Expr))) \
555 { /* likely */ } \
556 else \
557 break
558#endif
559
560/** @def ASSERT_GUEST_MSG_STMT_BREAK
561 * Assert that an expression is true and breaks if it isn't.
562 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before doing break.
563 *
564 * @param a_Expr Expression which should be true.
565 * @param a printf argument list (in parenthesis).
566 * @param a_Stmt Statement to execute before break in case of a failed assertion.
567 */
568#ifdef VBOX_STRICT_GUEST
569# define ASSERT_GUEST_MSG_STMT_BREAK(a_Expr, a, a_Stmt) \
570 if (RT_LIKELY(!!(a_Expr))) \
571 { /* likely */ } \
572 else if (1) \
573 { \
574 ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
575 RTAssertMsg2Weak a; \
576 ASSERT_GUEST_PANIC(); \
577 a_Stmt; \
578 break; \
579 } else \
580 break
581#else
582# define ASSERT_GUEST_MSG_STMT_BREAK(a_Expr, a, a_Stmt) \
583 if (RT_LIKELY(!!(a_Expr))) \
584 { /* likely */ } \
585 else if (1) \
586 { \
587 a_Stmt; \
588 break; \
589 } else \
590 break
591#endif
592
593/** @def ASSERT_GUEST_FAILED
594 * An assertion failed, hit breakpoint.
595 */
596#ifdef VBOX_STRICT_GUEST
597# define ASSERT_GUEST_FAILED() \
598 do { \
599 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
600 ASSERT_GUEST_PANIC(); \
601 } while (0)
602#else
603# define ASSERT_GUEST_FAILED() do { } while (0)
604#endif
605
606/** @def ASSERT_GUEST_FAILED_STMT
607 * An assertion failed, hit breakpoint and execute statement.
608 */
609#ifdef VBOX_STRICT_GUEST
610# define ASSERT_GUEST_FAILED_STMT(a_Stmt) \
611 do { \
612 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
613 ASSERT_GUEST_PANIC(); \
614 a_Stmt; \
615 } while (0)
616#else
617# define ASSERT_GUEST_FAILED_STMT(a_Stmt) do { a_Stmt; } while (0)
618#endif
619
620/** @def ASSERT_GUEST_FAILED_RETURN
621 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only) and return.
622 *
623 * @param a_rc The a_rc to return.
624 */
625#ifdef VBOX_STRICT_GUEST
626# define ASSERT_GUEST_FAILED_RETURN(a_rc) \
627 do { \
628 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
629 ASSERT_GUEST_PANIC(); \
630 return (a_rc); \
631 } while (0)
632#else
633# define ASSERT_GUEST_FAILED_RETURN(a_rc) \
634 do { \
635 return (a_rc); \
636 } while (0)
637#endif
638
639/** @def ASSERT_GUEST_FAILED_STMT_RETURN
640 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute a
641 * statement and return a value.
642 *
643 * @param a_Stmt The statement to execute before returning.
644 * @param a_rc The value to return.
645 */
646#ifdef VBOX_STRICT_GUEST
647# define ASSERT_GUEST_FAILED_STMT_RETURN(a_Stmt, a_rc) \
648 do { \
649 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
650 ASSERT_GUEST_PANIC(); \
651 a_Stmt; \
652 return (a_rc); \
653 } while (0)
654#else
655# define ASSERT_GUEST_FAILED_STMT_RETURN(a_Stmt, a_rc) \
656 do { \
657 a_Stmt; \
658 return (a_rc); \
659 } while (0)
660#endif
661
662/** @def ASSERT_GUEST_FAILED_RETURN_VOID
663 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only) and return.
664 */
665#ifdef VBOX_STRICT_GUEST
666# define ASSERT_GUEST_FAILED_RETURN_VOID() \
667 do { \
668 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
669 ASSERT_GUEST_PANIC(); \
670 return; \
671 } while (0)
672#else
673# define ASSERT_GUEST_FAILED_RETURN_VOID() \
674 do { \
675 return; \
676 } while (0)
677#endif
678
679/** @def ASSERT_GUEST_FAILED_STMT_RETURN_VOID
680 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute a
681 * statement and return.
682 *
683 * @param a_Stmt The statement to execute before returning.
684 */
685#ifdef VBOX_STRICT_GUEST
686# define ASSERT_GUEST_FAILED_STMT_RETURN_VOID(a_Stmt) \
687 do { \
688 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
689 ASSERT_GUEST_PANIC(); \
690 a_Stmt; \
691 return; \
692 } while (0)
693#else
694# define ASSERT_GUEST_FAILED_STMT_RETURN_VOID(a_Stmt) \
695 do { \
696 a_Stmt; \
697 return; \
698 } while (0)
699#endif
700
701
702/** @def ASSERT_GUEST_FAILED_BREAK
703 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only) and break.
704 */
705#ifdef VBOX_STRICT_GUEST
706# define ASSERT_GUEST_FAILED_BREAK() \
707 if (1) { \
708 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
709 ASSERT_GUEST_PANIC(); \
710 break; \
711 } else \
712 break
713#else
714# define ASSERT_GUEST_FAILED_BREAK() \
715 if (1) \
716 break; \
717 else \
718 break
719#endif
720
721/** @def ASSERT_GUEST_FAILED_STMT_BREAK
722 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute
723 * the given statement and break.
724 *
725 * @param a_Stmt Statement to execute before break.
726 */
727#ifdef VBOX_STRICT_GUEST
728# define ASSERT_GUEST_FAILED_STMT_BREAK(a_Stmt) \
729 if (1) { \
730 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
731 ASSERT_GUEST_PANIC(); \
732 a_Stmt; \
733 break; \
734 } else \
735 break
736#else
737# define ASSERT_GUEST_FAILED_STMT_BREAK(a_Stmt) \
738 if (1) { \
739 a_Stmt; \
740 break; \
741 } else \
742 break
743#endif
744
745
746/** @def ASSERT_GUEST_MSG_FAILED
747 * An assertion failed print a message and a hit breakpoint.
748 *
749 * @param a printf argument list (in parenthesis).
750 */
751#ifdef VBOX_STRICT_GUEST
752# define ASSERT_GUEST_MSG_FAILED(a) \
753 do { \
754 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
755 RTAssertMsg2Weak a; \
756 ASSERT_GUEST_PANIC(); \
757 } while (0)
758#else
759# define ASSERT_GUEST_MSG_FAILED(a) do { } while (0)
760#endif
761
762/** @def ASSERT_GUEST_MSG_FAILED_RETURN
763 * An assertion failed, hit breakpoint with message (VBOX_STRICT_GUEST mode only) and return.
764 *
765 * @param a printf argument list (in parenthesis).
766 * @param a_rc What is to be presented to return.
767 */
768#ifdef VBOX_STRICT_GUEST
769# define ASSERT_GUEST_MSG_FAILED_RETURN(a, a_rc) \
770 do { \
771 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
772 RTAssertMsg2Weak a; \
773 ASSERT_GUEST_PANIC(); \
774 return (a_rc); \
775 } while (0)
776#else
777# define ASSERT_GUEST_MSG_FAILED_RETURN(a, a_rc) \
778 do { \
779 return (a_rc); \
780 } while (0)
781#endif
782
783/** @def ASSERT_GUEST_MSG_FAILED_RETURN_VOID
784 * An assertion failed, hit breakpoint with message (VBOX_STRICT_GUEST mode only) and return.
785 *
786 * @param a printf argument list (in parenthesis).
787 */
788#ifdef VBOX_STRICT_GUEST
789# define ASSERT_GUEST_MSG_FAILED_RETURN_VOID(a) \
790 do { \
791 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
792 RTAssertMsg2Weak a; \
793 ASSERT_GUEST_PANIC(); \
794 return; \
795 } while (0)
796#else
797# define ASSERT_GUEST_MSG_FAILED_RETURN_VOID(a) \
798 do { \
799 return; \
800 } while (0)
801#endif
802
803
804/** @def ASSERT_GUEST_MSG_FAILED_BREAK
805 * An assertion failed, hit breakpoint with message (VBOX_STRICT_GUEST mode only) and break.
806 *
807 * @param a printf argument list (in parenthesis).
808 */
809#ifdef VBOX_STRICT_GUEST
810# define ASSERT_GUEST_MSG_FAILED_BREAK(a) \
811 if (1) { \
812 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
813 RTAssertMsg2Weak a; \
814 ASSERT_GUEST_PANIC(); \
815 break; \
816 } else \
817 break
818#else
819# define ASSERT_GUEST_MSG_FAILED_BREAK(a) \
820 if (1) \
821 break; \
822 else \
823 break
824#endif
825
826/** @def ASSERT_GUEST_MSG_FAILED_STMT_BREAK
827 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute
828 * the given statement and break.
829 *
830 * @param a printf argument list (in parenthesis).
831 * @param a_Stmt Statement to execute before break.
832 */
833#ifdef VBOX_STRICT_GUEST
834# define ASSERT_GUEST_MSG_FAILED_STMT_BREAK(a, a_Stmt) \
835 if (1) { \
836 ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
837 RTAssertMsg2Weak a; \
838 ASSERT_GUEST_PANIC(); \
839 a_Stmt; \
840 break; \
841 } else \
842 break
843#else
844# define ASSERT_GUEST_MSG_FAILED_STMT_BREAK(a, a_Stmt) \
845 if (1) { \
846 a_Stmt; \
847 break; \
848 } else \
849 break
850#endif
851
852/** @} */
853
854
855
856/** @name Guest input release log assertions
857 *
858 * These assertions will work like normal strict assertion when VBOX_STRICT_GUEST is
859 * defined and LogRel statements when VBOX_STRICT_GUEST is undefined. Typically
860 * used for important guest input that it would be helpful to find in VBox.log
861 * if the guest doesn't get it right.
862 *
863 * @{
864 */
865
866
867/** @def ASSERT_GUEST_LOGREL_MSG1
868 * RTAssertMsg1Weak (strict builds) / LogRel wrapper (non-strict).
869 */
870#ifdef VBOX_STRICT_GUEST
871# define ASSERT_GUEST_LOGREL_MSG1(szExpr, iLine, pszFile, pszFunction) \
872 RTAssertMsg1Weak("guest-input: " szExpr, iLine, pszFile, pszFunction)
873#else
874# define ASSERT_GUEST_LOGREL_MSG1(szExpr, iLine, pszFile, pszFunction) \
875 LogRel(("ASSERT_GUEST_LOGREL %s(%d) %s: %s\n", (pszFile), (iLine), (pszFunction), (szExpr) ))
876#endif
877
878/** @def ASSERT_GUEST_LOGREL_MSG2
879 * RTAssertMsg2Weak (strict builds) / LogRel wrapper (non-strict).
880 */
881#ifdef VBOX_STRICT_GUEST
882# define ASSERT_GUEST_LOGREL_MSG2(a) RTAssertMsg2Weak a
883#else
884# define ASSERT_GUEST_LOGREL_MSG2(a) LogRel(a)
885#endif
886
887/** @def ASSERT_GUEST_LOGREL
888 * Assert that an expression is true.
889 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
890 *
891 * @param a_Expr Expression which should be true.
892 */
893#define ASSERT_GUEST_LOGREL(a_Expr) \
894 do { \
895 if (RT_LIKELY(!!(a_Expr))) \
896 { /* likely */ } \
897 else \
898 { \
899 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
900 ASSERT_GUEST_PANIC(); \
901 } \
902 } while (0)
903
904/** @def ASSERT_GUEST_LOGREL_RETURN
905 * Assert that an expression is true, return \a a_rc if it isn't.
906 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
907 *
908 * @param a_Expr Expression which should be true.
909 * @param a_rc What is to be presented to return.
910 */
911#define ASSERT_GUEST_LOGREL_RETURN(a_Expr, a_rc) \
912 do { \
913 if (RT_LIKELY(!!(a_Expr))) \
914 { /* likely */ } \
915 else \
916 { \
917 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
918 ASSERT_GUEST_PANIC(); \
919 return (a_rc); \
920 } \
921 } while (0)
922
923/** @def ASSERT_GUEST_LOGREL_RETURN_VOID
924 * Assert that an expression is true, return void if it isn't.
925 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
926 *
927 * @param a_Expr Expression which should be true.
928 */
929#define ASSERT_GUEST_LOGREL_RETURN_VOID(a_Expr) \
930 do { \
931 if (RT_LIKELY(!!(a_Expr))) \
932 { /* likely */ } \
933 else \
934 { \
935 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
936 ASSERT_GUEST_PANIC(); \
937 return; \
938 } \
939 } while (0)
940
941/** @def ASSERT_GUEST_LOGREL_BREAK
942 * Assert that an expression is true, break if it isn't.
943 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
944 *
945 * @param a_Expr Expression which should be true.
946 */
947#define ASSERT_GUEST_LOGREL_BREAK(a_Expr) \
948 if (RT_LIKELY(!!(a_Expr))) \
949 { /* likely */ } \
950 else if (1) \
951 { \
952 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
953 ASSERT_GUEST_PANIC(); \
954 break; \
955 } \
956 else \
957 break
958
959/** @def ASSERT_GUEST_LOGREL_STMT_BREAK
960 * Assert that an expression is true, execute \a a_Stmt and break if it isn't.
961 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
962 *
963 * @param a_Expr Expression which should be true.
964 * @param a_Stmt Statement to execute before break in case of a failed assertion.
965 */
966#define ASSERT_GUEST_LOGREL_STMT_BREAK(a_Expr, a_Stmt) \
967 if (RT_LIKELY(!!(a_Expr))) \
968 { /* likely */ } \
969 else if (1) \
970 { \
971 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
972 ASSERT_GUEST_PANIC(); \
973 a_Stmt; \
974 break; \
975 } else \
976 break
977
978/** @def ASSERT_GUEST_LOGREL_MSG
979 * Assert that an expression is true.
980 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
981 *
982 * @param a_Expr Expression which should be true.
983 * @param a printf argument list (in parenthesis).
984 */
985#define ASSERT_GUEST_LOGREL_MSG(a_Expr, a) \
986 do { \
987 if (RT_LIKELY(!!(a_Expr))) \
988 { /* likely */ } \
989 else\
990 { \
991 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
992 ASSERT_GUEST_LOGREL_MSG2(a); \
993 ASSERT_GUEST_PANIC(); \
994 } \
995 } while (0)
996
997/** @def ASSERT_GUEST_LOGREL_MSG_STMT
998 * Assert that an expression is true, execute \a a_Stmt and break if it isn't
999 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1000 *
1001 * @param a_Expr Expression which should be true.
1002 * @param a printf argument list (in parenthesis).
1003 * @param a_Stmt Statement to execute in case of a failed assertion.
1004 */
1005#define ASSERT_GUEST_LOGREL_MSG_STMT(a_Expr, a, a_Stmt) \
1006 do { \
1007 if (RT_LIKELY(!!(a_Expr))) \
1008 { /* likely */ } \
1009 else\
1010 { \
1011 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1012 ASSERT_GUEST_LOGREL_MSG2(a); \
1013 ASSERT_GUEST_PANIC(); \
1014 a_Stmt; \
1015 } \
1016 } while (0)
1017
1018/** @def ASSERT_GUEST_LOGREL_MSG_RETURN
1019 * Assert that an expression is true, return \a a_rc if it isn't.
1020 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1021 *
1022 * @param a_Expr Expression which should be true.
1023 * @param a printf argument list (in parenthesis).
1024 * @param a_rc What is to be presented to return.
1025 */
1026#define ASSERT_GUEST_LOGREL_MSG_RETURN(a_Expr, a, a_rc) \
1027 do { \
1028 if (RT_LIKELY(!!(a_Expr))) \
1029 { /* likely */ } \
1030 else\
1031 { \
1032 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1033 ASSERT_GUEST_LOGREL_MSG2(a); \
1034 ASSERT_GUEST_PANIC(); \
1035 return (a_rc); \
1036 } \
1037 } while (0)
1038
1039/** @def ASSERT_GUEST_LOGREL_MSG_STMT_RETURN
1040 * Assert that an expression is true, execute @a a_Stmt and return @a rcRet if it
1041 * isn't.
1042 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1043 *
1044 * @param a_Expr Expression which should be true.
1045 * @param a printf argument list (in parenthesis).
1046 * @param a_Stmt Statement to execute before returning in case of a failed
1047 * assertion.
1048 * @param rcRet What is to be presented to return.
1049 */
1050#define ASSERT_GUEST_LOGREL_MSG_STMT_RETURN(a_Expr, a, a_Stmt, rcRet) \
1051 do { \
1052 if (RT_LIKELY(!!(a_Expr))) \
1053 { /* likely */ } \
1054 else\
1055 { \
1056 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1057 ASSERT_GUEST_LOGREL_MSG2(a); \
1058 ASSERT_GUEST_PANIC(); \
1059 a_Stmt; \
1060 return (rcRet); \
1061 } \
1062 } while (0)
1063
1064/** @def ASSERT_GUEST_LOGREL_MSG_RETURN_VOID
1065 * Assert that an expression is true, return (void) if it isn't.
1066 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1067 *
1068 * @param a_Expr Expression which should be true.
1069 * @param a printf argument list (in parenthesis).
1070 */
1071#define ASSERT_GUEST_LOGREL_MSG_RETURN_VOID(a_Expr, a) \
1072 do { \
1073 if (RT_LIKELY(!!(a_Expr))) \
1074 { /* likely */ } \
1075 else\
1076 { \
1077 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1078 ASSERT_GUEST_LOGREL_MSG2(a); \
1079 ASSERT_GUEST_PANIC(); \
1080 return; \
1081 } \
1082 } while (0)
1083
1084/** @def ASSERT_GUEST_LOGREL_MSG_BREAK
1085 * Assert that an expression is true, break if it isn't.
1086 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1087 *
1088 * @param a_Expr Expression which should be true.
1089 * @param a printf argument list (in parenthesis).
1090 */
1091#define ASSERT_GUEST_LOGREL_MSG_BREAK(a_Expr, a) \
1092 if (RT_LIKELY(!!(a_Expr))) \
1093 { /* likely */ } \
1094 else if (1) \
1095 { \
1096 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1097 ASSERT_GUEST_LOGREL_MSG2(a); \
1098 ASSERT_GUEST_PANIC(); \
1099 break; \
1100 } \
1101 else \
1102 break
1103
1104/** @def ASSERT_GUEST_LOGREL_MSG_STMT_BREAK
1105 * Assert that an expression is true, execute \a a_Stmt and break if it isn't.
1106 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1107 *
1108 * @param a_Expr Expression which should be true.
1109 * @param a printf argument list (in parenthesis).
1110 * @param a_Stmt Statement to execute before break in case of a failed assertion.
1111 */
1112#define ASSERT_GUEST_LOGREL_MSG_STMT_BREAK(a_Expr, a, a_Stmt) \
1113 if (RT_LIKELY(!!(a_Expr))) \
1114 { /* likely */ } \
1115 else if (1) \
1116 { \
1117 ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1118 ASSERT_GUEST_LOGREL_MSG2(a); \
1119 ASSERT_GUEST_PANIC(); \
1120 a_Stmt; \
1121 break; \
1122 } else \
1123 break
1124
1125/** @def ASSERT_GUEST_LOGREL_FAILED
1126 * An assertion failed.
1127 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1128 */
1129#define ASSERT_GUEST_LOGREL_FAILED() \
1130 do { \
1131 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1132 ASSERT_GUEST_PANIC(); \
1133 } while (0)
1134
1135/** @def ASSERT_GUEST_LOGREL_FAILED_RETURN
1136 * An assertion failed.
1137 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1138 *
1139 * @param a_rc What is to be presented to return.
1140 */
1141#define ASSERT_GUEST_LOGREL_FAILED_RETURN(a_rc) \
1142 do { \
1143 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1144 ASSERT_GUEST_PANIC(); \
1145 return (a_rc); \
1146 } while (0)
1147
1148/** @def ASSERT_GUEST_LOGREL_FAILED_RETURN_VOID
1149 * An assertion failed, hit a breakpoint and return.
1150 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1151 */
1152#define ASSERT_GUEST_LOGREL_FAILED_RETURN_VOID() \
1153 do { \
1154 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1155 ASSERT_GUEST_PANIC(); \
1156 return; \
1157 } while (0)
1158
1159/** @def ASSERT_GUEST_LOGREL_FAILED_BREAK
1160 * An assertion failed, break.
1161 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1162 */
1163#define ASSERT_GUEST_LOGREL_FAILED_BREAK() \
1164 if (1) \
1165 { \
1166 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1167 ASSERT_GUEST_PANIC(); \
1168 break; \
1169 } else \
1170 break
1171
1172/** @def ASSERT_GUEST_LOGREL_FAILED_STMT_BREAK
1173 * An assertion failed, execute \a a_Stmt and break.
1174 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1175 *
1176 * @param a_Stmt Statement to execute before break.
1177 */
1178#define ASSERT_GUEST_LOGREL_FAILED_STMT_BREAK(a_Stmt) \
1179 if (1) \
1180 { \
1181 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1182 ASSERT_GUEST_PANIC(); \
1183 a_Stmt; \
1184 break; \
1185 } else \
1186 break
1187
1188/** @def ASSERT_GUEST_LOGREL_MSG_FAILED
1189 * An assertion failed.
1190 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1191 *
1192 * @param a printf argument list (in parenthesis).
1193 */
1194#define ASSERT_GUEST_LOGREL_MSG_FAILED(a) \
1195 do { \
1196 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1197 ASSERT_GUEST_LOGREL_MSG2(a); \
1198 ASSERT_GUEST_PANIC(); \
1199 } while (0)
1200
1201/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT
1202 * An assertion failed, execute @a a_Stmt.
1203 *
1204 * Strict builds will hit a breakpoint, non-strict will only do LogRel. The
1205 * statement will be executed in regardless of build type.
1206 *
1207 * @param a printf argument list (in parenthesis).
1208 * @param a_Stmt Statement to execute after raising/logging the assertion.
1209 */
1210#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT(a, a_Stmt) \
1211 do { \
1212 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1213 ASSERT_GUEST_LOGREL_MSG2(a); \
1214 ASSERT_GUEST_PANIC(); \
1215 a_Stmt; \
1216 } while (0)
1217
1218/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN
1219 * An assertion failed, return \a a_rc.
1220 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1221 *
1222 * @param a printf argument list (in parenthesis).
1223 * @param a_rc What is to be presented to return.
1224 */
1225#define ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN(a, a_rc) \
1226 do { \
1227 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1228 ASSERT_GUEST_LOGREL_MSG2(a); \
1229 ASSERT_GUEST_PANIC(); \
1230 return (a_rc); \
1231 } while (0)
1232
1233/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN
1234 * An assertion failed, execute @a a_Stmt and return @a a_rc.
1235 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1236 *
1237 * @param a printf argument list (in parenthesis).
1238 * @param a_Stmt Statement to execute before returning in case of a failed
1239 * assertion.
1240 * @param a_rc What is to be presented to return.
1241 */
1242#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN(a, a_Stmt, a_rc) \
1243 do { \
1244 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1245 ASSERT_GUEST_LOGREL_MSG2(a); \
1246 ASSERT_GUEST_PANIC(); \
1247 a_Stmt; \
1248 return (a_rc); \
1249 } while (0)
1250
1251/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN_VOID
1252 * An assertion failed, return void.
1253 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1254 *
1255 * @param a printf argument list (in parenthesis).
1256 */
1257#define ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN_VOID(a) \
1258 do { \
1259 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1260 ASSERT_GUEST_LOGREL_MSG2(a); \
1261 ASSERT_GUEST_PANIC(); \
1262 return; \
1263 } while (0)
1264
1265/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN_VOID
1266 * An assertion failed, execute @a a_Stmt and return void.
1267 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1268 *
1269 * @param a printf argument list (in parenthesis).
1270 * @param a_Stmt Statement to execute before returning in case of a failed
1271 * assertion.
1272 */
1273#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN_VOID(a, a_Stmt) \
1274 do { \
1275 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1276 ASSERT_GUEST_LOGREL_MSG2(a); \
1277 ASSERT_GUEST_PANIC(); \
1278 a_Stmt; \
1279 return; \
1280 } while (0)
1281
1282/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_BREAK
1283 * An assertion failed, break.
1284 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1285 *
1286 * @param a printf argument list (in parenthesis).
1287 */
1288#define ASSERT_GUEST_LOGREL_MSG_FAILED_BREAK(a) \
1289 if (1)\
1290 { \
1291 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1292 ASSERT_GUEST_LOGREL_MSG2(a); \
1293 ASSERT_GUEST_PANIC(); \
1294 break; \
1295 } else \
1296 break
1297
1298/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_BREAK
1299 * An assertion failed, execute \a a_Stmt and break.
1300 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1301 *
1302 * @param a printf argument list (in parenthesis).
1303 * @param a_Stmt Statement to execute before break.
1304 */
1305#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_BREAK(a, a_Stmt) \
1306 if (1) \
1307 { \
1308 ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1309 ASSERT_GUEST_LOGREL_MSG2(a); \
1310 ASSERT_GUEST_PANIC(); \
1311 a_Stmt; \
1312 break; \
1313 } else \
1314 break
1315
1316/** @} */
1317
1318
1319/** @name Convenience Assertions Macros
1320 * @{
1321 */
1322
1323/** @def ASSERT_GUEST_RC
1324 * Asserts a iprt status code successful.
1325 *
1326 * On failure it will print info about the rc and hit a breakpoint.
1327 *
1328 * @param rc iprt status code.
1329 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1330 */
1331#define ASSERT_GUEST_RC(rc) ASSERT_GUEST_MSG_RC(rc, ("%Rra\n", (rc)))
1332
1333/** @def ASSERT_GUEST_RC_STMT
1334 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and execute
1335 * @a stmt if it isn't.
1336 *
1337 * @param rc iprt status code.
1338 * @param stmt Statement to execute before returning in case of a failed
1339 * assertion.
1340 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1341 */
1342#define ASSERT_GUEST_RC_STMT(rc, stmt) ASSERT_GUEST_MSG_RC_STMT(rc, ("%Rra\n", (rc)), stmt)
1343
1344/** @def ASSERT_GUEST_RC_RETURN
1345 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1346 *
1347 * @param rc iprt status code.
1348 * @param rcRet What is to be presented to return.
1349 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1350 */
1351#define ASSERT_GUEST_RC_RETURN(rc, rcRet) ASSERT_GUEST_MSG_RC_RETURN(rc, ("%Rra\n", (rc)), rcRet)
1352
1353/** @def ASSERT_GUEST_RC_STMT_RETURN
1354 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1355 * @a stmt and returns @a rcRet if it isn't.
1356 *
1357 * @param rc iprt status code.
1358 * @param stmt Statement to execute before returning in case of a failed
1359 * assertion.
1360 * @param rcRet What is to be presented to return.
1361 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1362 */
1363#define ASSERT_GUEST_RC_STMT_RETURN(rc, stmt, rcRet) ASSERT_GUEST_MSG_RC_STMT_RETURN(rc, ("%Rra\n", (rc)), stmt, rcRet)
1364
1365/** @def ASSERT_GUEST_RC_RETURN_VOID
1366 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1367 *
1368 * @param rc iprt status code.
1369 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1370 */
1371#define ASSERT_GUEST_RC_RETURN_VOID(rc) ASSERT_GUEST_MSG_RC_RETURN_VOID(rc, ("%Rra\n", (rc)))
1372
1373/** @def ASSERT_GUEST_RC_STMT_RETURN_VOID
1374 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
1375 * execute the given statement/return if it isn't.
1376 *
1377 * @param rc iprt status code.
1378 * @param stmt Statement to execute before returning on failure.
1379 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1380 */
1381#define ASSERT_GUEST_RC_STMT_RETURN_VOID(rc, stmt) ASSERT_GUEST_MSG_RC_STMT_RETURN_VOID(rc, ("%Rra\n", (rc)), stmt)
1382
1383/** @def ASSERT_GUEST_RC_BREAK
1384 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
1385 *
1386 * @param rc iprt status code.
1387 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1388 */
1389#define ASSERT_GUEST_RC_BREAK(rc) ASSERT_GUEST_MSG_RC_BREAK(rc, ("%Rra\n", (rc)))
1390
1391/** @def ASSERT_GUEST_RC_STMT_BREAK
1392 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
1393 *
1394 * @param rc iprt status code.
1395 * @param stmt Statement to execute before break in case of a failed assertion.
1396 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1397 */
1398#define ASSERT_GUEST_RC_STMT_BREAK(rc, stmt) ASSERT_GUEST_MSG_RC_STMT_BREAK(rc, ("%Rra\n", (rc)), stmt)
1399
1400/** @def ASSERT_GUEST_MSG_RC
1401 * Asserts a iprt status code successful.
1402 *
1403 * It prints a custom message and hits a breakpoint on FAILURE.
1404 *
1405 * @param rc iprt status code.
1406 * @param msg printf argument list (in parenthesis).
1407 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1408 */
1409#define ASSERT_GUEST_MSG_RC(rc, msg) \
1410 do { ASSERT_GUEST_MSG(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
1411
1412/** @def ASSERT_GUEST_MSG_RC_STMT
1413 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and
1414 * execute @a stmt if it isn't.
1415 *
1416 * @param rc iprt status code.
1417 * @param msg printf argument list (in parenthesis).
1418 * @param stmt Statement to execute before returning in case of a failed
1419 * assertion.
1420 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1421 */
1422#define ASSERT_GUEST_MSG_RC_STMT(rc, msg, stmt) \
1423 do { ASSERT_GUEST_MSG_STMT(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
1424
1425/** @def ASSERT_GUEST_MSG_RC_RETURN
1426 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
1427 * @a rcRet if it isn't.
1428 *
1429 * @param rc iprt status code.
1430 * @param msg printf argument list (in parenthesis).
1431 * @param rcRet What is to be presented to return.
1432 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1433 */
1434#define ASSERT_GUEST_MSG_RC_RETURN(rc, msg, rcRet) \
1435 do { ASSERT_GUEST_MSG_RETURN(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)
1436
1437/** @def ASSERT_GUEST_MSG_RC_STMT_RETURN
1438 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1439 * @a stmt and return @a rcRet if it isn't.
1440 *
1441 * @param rc iprt status code.
1442 * @param msg printf argument list (in parenthesis).
1443 * @param stmt Statement to execute before returning in case of a failed
1444 * assertion.
1445 * @param rcRet What is to be presented to return.
1446 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1447 */
1448#define ASSERT_GUEST_MSG_RC_STMT_RETURN(rc, msg, stmt, rcRet) \
1449 do { ASSERT_GUEST_MSG_STMT_RETURN(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)
1450
1451/** @def ASSERT_GUEST_MSG_RC_RETURN_VOID
1452 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
1453 * void if it isn't.
1454 *
1455 * @param rc iprt status code.
1456 * @param msg printf argument list (in parenthesis).
1457 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1458 */
1459#define ASSERT_GUEST_MSG_RC_RETURN_VOID(rc, msg) \
1460 do { ASSERT_GUEST_MSG_RETURN_VOID(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
1461
1462/** @def ASSERT_GUEST_MSG_RC_STMT_RETURN_VOID
1463 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1464 * @a stmt and return void if it isn't.
1465 *
1466 * @param rc iprt status code.
1467 * @param msg printf argument list (in parenthesis).
1468 * @param stmt Statement to execute before break in case of a failed assertion.
1469 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1470 */
1471#define ASSERT_GUEST_MSG_RC_STMT_RETURN_VOID(rc, msg, stmt) \
1472 do { ASSERT_GUEST_MSG_STMT_RETURN_VOID(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
1473
1474/** @def ASSERT_GUEST_MSG_RC_BREAK
1475 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break
1476 * if it isn't.
1477 *
1478 * @param rc iprt status code.
1479 * @param msg printf argument list (in parenthesis).
1480 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1481 */
1482#define ASSERT_GUEST_MSG_RC_BREAK(rc, msg) \
1483 if (1) { ASSERT_GUEST_MSG_BREAK(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)
1484
1485/** @def ASSERT_GUEST_MSG_RC_STMT_BREAK
1486 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1487 * @a stmt and break if it isn't.
1488 *
1489 * @param rc iprt status code.
1490 * @param msg printf argument list (in parenthesis).
1491 * @param stmt Statement to execute before break in case of a failed assertion.
1492 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1493 */
1494#define ASSERT_GUEST_MSG_RC_STMT_BREAK(rc, msg, stmt) \
1495 if (1) { ASSERT_GUEST_MSG_STMT_BREAK(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)
1496
1497/** @def ASSERT_GUEST_RC_SUCCESS
1498 * Asserts an iprt status code equals VINF_SUCCESS.
1499 *
1500 * On failure it will print info about the rc and hit a breakpoint.
1501 *
1502 * @param rc iprt status code.
1503 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1504 */
1505#define ASSERT_GUEST_RC_SUCCESS(rc) do { ASSERT_GUEST_MSG((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)
1506
1507/** @def ASSERT_GUEST_RC_SUCCESS_RETURN
1508 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
1509 *
1510 * @param rc iprt status code.
1511 * @param rcRet What is to be presented to return.
1512 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1513 */
1514#define ASSERT_GUEST_RC_SUCCESS_RETURN(rc, rcRet) ASSERT_GUEST_MSG_RETURN((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
1515
1516/** @def ASSERT_GUEST_RC_SUCCESS_RETURN_VOID
1517 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
1518 *
1519 * @param rc iprt status code.
1520 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1521 */
1522#define ASSERT_GUEST_RC_SUCCESS_RETURN_VOID(rc) ASSERT_GUEST_MSG_RETURN_VOID((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
1523
1524/** @def ASSERT_GUEST_RC_SUCCESS_BREAK
1525 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
1526 *
1527 * @param rc iprt status code.
1528 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1529 */
1530#define ASSERT_GUEST_RC_SUCCESS_BREAK(rc) ASSERT_GUEST_MSG_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
1531
1532/** @def ASSERT_GUEST_RC_SUCCESS_STMT_BREAK
1533 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
1534 *
1535 * @param rc iprt status code.
1536 * @param stmt Statement to execute before break in case of a failed assertion.
1537 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1538 */
1539#define ASSERT_GUEST_RC_SUCCESS_STMT_BREAK(rc, stmt) ASSERT_GUEST_MSG_STMT_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
1540
1541/** @def ASSERT_GUEST_GCPHYS32
1542 * Asserts that the high dword of a physical address is zero
1543 *
1544 * @param GCPhys The address (RTGCPHYS).
1545 */
1546#define ASSERT_GUEST_GCPHYS32(GCPhys) ASSERT_GUEST_MSG(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))
1547
1548
1549/** @def ASSERT_GUEST_RC
1550 * Asserts a iprt status code successful.
1551 *
1552 * On failure it will print info about the rc and hit a breakpoint.
1553 *
1554 * @param rc iprt status code.
1555 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1556 */
1557#define ASSERT_GUEST_LOGREL_RC(rc) ASSERT_GUEST_LOGREL_MSG_RC(rc, ("%Rra\n", (rc)))
1558
1559/** @def ASSERT_GUEST_LOGREL_RC_STMT
1560 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and execute
1561 * @a stmt if it isn't.
1562 *
1563 * @param rc iprt status code.
1564 * @param stmt Statement to execute before returning in case of a failed
1565 * assertion.
1566 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1567 */
1568#define ASSERT_GUEST_LOGREL_RC_STMT(rc, stmt) ASSERT_GUEST_LOGREL_MSG_RC_STMT(rc, ("%Rra\n", (rc)), stmt)
1569
1570/** @def ASSERT_GUEST_LOGREL_RC_RETURN
1571 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1572 *
1573 * @param rc iprt status code.
1574 * @param rcRet What is to be presented to return.
1575 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1576 */
1577#define ASSERT_GUEST_LOGREL_RC_RETURN(rc, rcRet) ASSERT_GUEST_LOGREL_MSG_RC_RETURN(rc, ("%Rra\n", (rc)), rcRet)
1578
1579/** @def ASSERT_GUEST_LOGREL_RC_STMT_RETURN
1580 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1581 * @a stmt and returns @a rcRet if it isn't.
1582 *
1583 * @param rc iprt status code.
1584 * @param stmt Statement to execute before returning in case of a failed
1585 * assertion.
1586 * @param rcRet What is to be presented to return.
1587 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1588 */
1589#define ASSERT_GUEST_LOGREL_RC_STMT_RETURN(rc, stmt, rcRet) ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN(rc, ("%Rra\n", (rc)), stmt, rcRet)
1590
1591/** @def ASSERT_GUEST_LOGREL_RC_RETURN_VOID
1592 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1593 *
1594 * @param rc iprt status code.
1595 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1596 */
1597#define ASSERT_GUEST_LOGREL_RC_RETURN_VOID(rc) ASSERT_GUEST_LOGREL_MSG_RC_RETURN_VOID(rc, ("%Rra\n", (rc)))
1598
1599/** @def ASSERT_GUEST_LOGREL_RC_STMT_RETURN_VOID
1600 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
1601 * execute the given statement/return if it isn't.
1602 *
1603 * @param rc iprt status code.
1604 * @param stmt Statement to execute before returning on failure.
1605 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1606 */
1607#define ASSERT_GUEST_LOGREL_RC_STMT_RETURN_VOID(rc, stmt) ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN_VOID(rc, ("%Rra\n", (rc)), stmt)
1608
1609/** @def ASSERT_GUEST_LOGREL_RC_BREAK
1610 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
1611 *
1612 * @param rc iprt status code.
1613 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1614 */
1615#define ASSERT_GUEST_LOGREL_RC_BREAK(rc) ASSERT_GUEST_LOGREL_MSG_RC_BREAK(rc, ("%Rra\n", (rc)))
1616
1617/** @def ASSERT_GUEST_LOGREL_RC_STMT_BREAK
1618 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
1619 *
1620 * @param rc iprt status code.
1621 * @param stmt Statement to execute before break in case of a failed assertion.
1622 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1623 */
1624#define ASSERT_GUEST_LOGREL_RC_STMT_BREAK(rc, stmt) ASSERT_GUEST_LOGREL_MSG_RC_STMT_BREAK(rc, ("%Rra\n", (rc)), stmt)
1625
1626/** @def ASSERT_GUEST_LOGREL_MSG_RC
1627 * Asserts a iprt status code successful.
1628 *
1629 * It prints a custom message and hits a breakpoint on FAILURE.
1630 *
1631 * @param rc iprt status code.
1632 * @param msg printf argument list (in parenthesis).
1633 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1634 */
1635#define ASSERT_GUEST_LOGREL_MSG_RC(rc, msg) \
1636 do { ASSERT_GUEST_LOGREL_MSG(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
1637
1638/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT
1639 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and
1640 * execute @a stmt if it isn't.
1641 *
1642 * @param rc iprt status code.
1643 * @param msg printf argument list (in parenthesis).
1644 * @param stmt Statement to execute before returning in case of a failed
1645 * assertion.
1646 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1647 */
1648#define ASSERT_GUEST_LOGREL_MSG_RC_STMT(rc, msg, stmt) \
1649 do { ASSERT_GUEST_LOGREL_MSG_STMT(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
1650
1651/** @def ASSERT_GUEST_LOGREL_MSG_RC_RETURN
1652 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
1653 * @a rcRet if it isn't.
1654 *
1655 * @param rc iprt status code.
1656 * @param msg printf argument list (in parenthesis).
1657 * @param rcRet What is to be presented to return.
1658 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1659 */
1660#define ASSERT_GUEST_LOGREL_MSG_RC_RETURN(rc, msg, rcRet) \
1661 do { ASSERT_GUEST_LOGREL_MSG_RETURN(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)
1662
1663/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN
1664 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1665 * @a stmt and return @a rcRet if it isn't.
1666 *
1667 * @param rc iprt status code.
1668 * @param msg printf argument list (in parenthesis).
1669 * @param stmt Statement to execute before returning in case of a failed
1670 * assertion.
1671 * @param rcRet What is to be presented to return.
1672 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1673 */
1674#define ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN(rc, msg, stmt, rcRet) \
1675 do { ASSERT_GUEST_LOGREL_MSG_STMT_RETURN(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)
1676
1677/** @def ASSERT_GUEST_LOGREL_MSG_RC_RETURN_VOID
1678 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
1679 * void if it isn't.
1680 *
1681 * @param rc iprt status code.
1682 * @param msg printf argument list (in parenthesis).
1683 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1684 */
1685#define ASSERT_GUEST_LOGREL_MSG_RC_RETURN_VOID(rc, msg) \
1686 do { ASSERT_GUEST_LOGREL_MSG_RETURN_VOID(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
1687
1688/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN_VOID
1689 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1690 * @a stmt and return void if it isn't.
1691 *
1692 * @param rc iprt status code.
1693 * @param msg printf argument list (in parenthesis).
1694 * @param stmt Statement to execute before break in case of a failed assertion.
1695 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1696 */
1697#define ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN_VOID(rc, msg, stmt) \
1698 do { ASSERT_GUEST_LOGREL_MSG_STMT_RETURN_VOID(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
1699
1700/** @def ASSERT_GUEST_LOGREL_MSG_RC_BREAK
1701 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break
1702 * if it isn't.
1703 *
1704 * @param rc iprt status code.
1705 * @param msg printf argument list (in parenthesis).
1706 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1707 */
1708#define ASSERT_GUEST_LOGREL_MSG_RC_BREAK(rc, msg) \
1709 if (1) { ASSERT_GUEST_LOGREL_MSG_BREAK(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)
1710
1711/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT_BREAK
1712 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1713 * @a stmt and break if it isn't.
1714 *
1715 * @param rc iprt status code.
1716 * @param msg printf argument list (in parenthesis).
1717 * @param stmt Statement to execute before break in case of a failed assertion.
1718 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1719 */
1720#define ASSERT_GUEST_LOGREL_MSG_RC_STMT_BREAK(rc, msg, stmt) \
1721 if (1) { ASSERT_GUEST_LOGREL_MSG_STMT_BREAK(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)
1722
1723/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS
1724 * Asserts an iprt status code equals VINF_SUCCESS.
1725 *
1726 * On failure it will print info about the rc and hit a breakpoint.
1727 *
1728 * @param rc iprt status code.
1729 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1730 */
1731#define ASSERT_GUEST_LOGREL_RC_SUCCESS(rc) do { ASSERT_GUEST_LOGREL_MSG((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)
1732
1733/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN
1734 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
1735 *
1736 * @param rc iprt status code.
1737 * @param rcRet What is to be presented to return.
1738 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1739 */
1740#define ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN(rc, rcRet) ASSERT_GUEST_LOGREL_MSG_RETURN((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
1741
1742/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN_VOID
1743 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
1744 *
1745 * @param rc iprt status code.
1746 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1747 */
1748#define ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN_VOID(rc) ASSERT_GUEST_LOGREL_MSG_RETURN_VOID((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
1749
1750/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_BREAK
1751 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
1752 *
1753 * @param rc iprt status code.
1754 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1755 */
1756#define ASSERT_GUEST_LOGREL_RC_SUCCESS_BREAK(rc) ASSERT_GUEST_LOGREL_MSG_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
1757
1758/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_STMT_BREAK
1759 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
1760 *
1761 * @param rc iprt status code.
1762 * @param stmt Statement to execute before break in case of a failed assertion.
1763 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1764 */
1765#define ASSERT_GUEST_LOGREL_RC_SUCCESS_STMT_BREAK(rc, stmt) ASSERT_GUEST_LOGREL_MSG_STMT_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
1766
1767/** @def ASSERT_GUEST_LOGREL_GCPHYS32
1768 * Asserts that the high dword of a physical address is zero
1769 *
1770 * @param GCPhys The address (RTGCPHYS).
1771 */
1772#define ASSERT_GUEST_LOGREL_GCPHYS32(GCPhys) ASSERT_GUEST_LOGREL_MSG(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))
1773
1774
1775/** @} */
1776
1777
1778/** @} */
1779
1780#endif /* !VBOX_INCLUDED_AssertGuest_h */
1781
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use