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

/** @file
 * VirtualBox - Guest input assertions.
 */

/*
 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * The contents of this file may alternatively be used under the terms
 * of the Common Development and Distribution License Version 1.0
 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
 * in the VirtualBox distribution, in which case the provisions of the
 * CDDL are applicable instead of those of the GPL.
 *
 * You may elect to license modified versions of this file under the
 * terms and conditions of either the GPL or the CDDL or both.
 *
 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
 */

#ifndef VBOX_INCLUDED_AssertGuest_h
#define VBOX_INCLUDED_AssertGuest_h
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include <VBox/cdefs.h>
#include <iprt/assert.h>


/** @defgroup grp_vbox_assert_guest VBox Guest Input Assertion Macros
 * @{
 */


/** @name Guest input assertions
 *
 * These assertions will only trigger when VBOX_STRICT_GUEST is defined.  When
 * it is undefined they will all be no-ops and generate no code, unless they
 * have other side effected (i.e. the _RETURN, _STMT, _BREAK variations).
 *
 * The assertions build on top of the functions in iprt/assert.h.
 *
 * @{
 */


/** @def ASSERT_GUEST_PANIC()
 * If VBOX_STRICT_GUEST is defined this macro will invoke RTAssertDoPanic if
 * RTAssertShouldPanic returns true. If VBOX_STRICT_GUEST isn't defined it won't
 * do any thing.
 */
#if defined(VBOX_STRICT_GUEST) && !defined(VBOX_STRICT_GUEST_DONT_PANIC)
# define ASSERT_GUEST_PANIC()   do { if (RTAssertShouldPanic()) RTAssertDoPanic(); } while (0)
#else
# define ASSERT_GUEST_PANIC()   do { } while (0)
#endif

/** Wrapper around RTAssertMsg1Weak that prefixes the expression. */
#define ASSERT_GUEST_MSG1(szExpr, iLine, pszFile, pszFunction) \
    RTAssertMsg1Weak("guest-input: " szExpr, iLine, pszFile, pszFunction)


/** @def ASSERT_GUEST
 * Assert that an expression is true. If false, hit breakpoint.
 * @param   a_Expr  Expression which should be true.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST(a_Expr)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
        } \
    } while (0)
#else
# define ASSERT_GUEST(a_Expr) do { } while (0)
#endif


/** @def ASSERT_GUEST_STMT
 * Assert that an expression is true. If false, hit breakpoint and execute the
 * statement.
 * @param   a_Expr  Expression which should be true.
 * @param   a_Stmt  Statement to execute on failure.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_STMT(a_Expr, a_Stmt)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
        } \
    } while (0)
#else
# define ASSERT_GUEST_STMT(a_Expr, a_Stmt)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            a_Stmt; \
        } \
    } while (0)
#endif


/** @def ASSERT_GUEST_RETURN
 * Assert that an expression is true and returns if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a_rc    What is to be presented to return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_RETURN(a_Expr, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
            return (a_rc); \
        } \
    } while (0)
#else
# define ASSERT_GUEST_RETURN(a_Expr, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
            return (a_rc); \
    } while (0)
#endif

/** @def ASSERT_GUEST_STMT_RETURN
 * Assert that an expression is true, if it isn't execute the given statement
 * and return rc.
 *
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before executing the statement and
 * returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a_Stmt  Statement to execute before returning on failure.
 * @param   a_rc    What is to be presented to return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_STMT_RETURN(a_Expr, a_Stmt, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
            return (a_rc); \
        } \
    } while (0)
#else
# define ASSERT_GUEST_STMT_RETURN(a_Expr, a_Stmt, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            a_Stmt; \
            return (a_rc); \
        } \
    } while (0)
#endif

/** @def ASSERT_GUEST_RETURN_VOID
 * Assert that an expression is true and returns if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_RETURN_VOID(a_Expr) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
            return; \
        } \
    } while (0)
#else
# define ASSERT_GUEST_RETURN_VOID(a_Expr) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
            return; \
    } while (0)
#endif

/** @def ASSERT_GUEST_STMT_RETURN_VOID
 * Assert that an expression is true, if it isn't execute the given statement
 * and return.
 *
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a_Stmt  Statement to execute before returning on failure.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_STMT_RETURN_VOID(a_Expr, a_Stmt) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
            return; \
        } \
    } while (0)
#else
# define ASSERT_GUEST_STMT_RETURN_VOID(a_Expr, a_Stmt) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            a_Stmt; \
            return; \
        } \
    } while (0)
#endif


/** @def ASSERT_GUEST_BREAK
 * Assert that an expression is true and breaks if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before breaking.
 *
 * @param   a_Expr  Expression which should be true.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_BREAK(a_Expr) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        break; \
    } else \
        break
#else
# define ASSERT_GUEST_BREAK(a_Expr) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else \
        break
#endif

/** @def ASSERT_GUEST_CONTINUE
 * Assert that an expression is true and continue if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before continuing.
 *
 * @param   a_Expr  Expression which should be true.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_CONTINUE(a_Expr) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        continue; \
    } else do {} while (0)
#else
# define ASSERT_GUEST_CONTINUE(a_Expr) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else \
        continue
#endif

/** @def ASSERT_GUEST_STMT_BREAK
 * Assert that an expression is true and breaks if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before doing break.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a_Stmt  Statement to execute before break in case of a failed assertion.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_STMT_BREAK(a_Expr, a_Stmt) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else do {} while (0)
#else
# define ASSERT_GUEST_STMT_BREAK(a_Expr, a_Stmt) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        a_Stmt; \
        break; \
    } else do {} while (0)
#endif


/** @def ASSERT_GUEST_MSG
 * Assert that an expression is true. If it's not print message and hit breakpoint.
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG(a_Expr, a)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
            RTAssertMsg2Weak a; \
            ASSERT_GUEST_PANIC(); \
        } \
    } while (0)
#else
# define ASSERT_GUEST_MSG(a_Expr, a)  do { } while (0)
#endif

/** @def ASSERT_GUEST_MSG_STMT
 * Assert that an expression is true.  If it's not print message and hit
 * breakpoint and execute the statement.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute in case of a failed assertion.
 *
 * @remarks The expression and statement will be evaluated in all build types.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_STMT(a_Expr, a, a_Stmt)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            RTAssertMsg2Weak a; \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
        } \
    } while (0)
#else
# define ASSERT_GUEST_MSG_STMT(a_Expr, a, a_Stmt)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            a_Stmt; \
        } \
    } while (0)
#endif

/** @def ASSERT_GUEST_MSG_RETURN
 * Assert that an expression is true and returns if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_rc    What is to be presented to return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_RETURN(a_Expr, a, a_rc)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
            RTAssertMsg2Weak a; \
            ASSERT_GUEST_PANIC(); \
            return (a_rc); \
        } \
    } while (0)
#else
# define ASSERT_GUEST_MSG_RETURN(a_Expr, a, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
            return (a_rc); \
    } while (0)
#endif

/** @def ASSERT_GUEST_MSG_STMT_RETURN
 * Assert that an expression is true, if it isn't execute the statement and
 * return.
 *
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before returning in case of a failed
 *                  assertion.
 * @param   a_rc    What is to be presented to return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_STMT_RETURN(a_Expr, a, a_Stmt, a_rc)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            RTAssertMsg2Weak a; \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
            return (a_rc); \
        } \
    } while (0)
#else
# define ASSERT_GUEST_MSG_STMT_RETURN(a_Expr, a, a_Stmt, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            a_Stmt; \
            return (a_rc); \
        } \
    } while (0)
#endif

/** @def ASSERT_GUEST_MSG_RETURN_VOID
 * Assert that an expression is true and returns if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_RETURN_VOID(a_Expr, a)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
            RTAssertMsg2Weak a; \
            ASSERT_GUEST_PANIC(); \
            return; \
        } \
    } while (0)
#else
# define ASSERT_GUEST_MSG_RETURN_VOID(a_Expr, a) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
            return; \
    } while (0)
#endif

/** @def ASSERT_GUEST_MSG_STMT_RETURN_VOID
 * Assert that an expression is true, if it isn't execute the statement and
 * return.
 *
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before return in case of a failed assertion.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_STMT_RETURN_VOID(a_Expr, a, a_Stmt)  \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            RTAssertMsg2Weak a; \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
            return; \
        } \
    } while (0)
#else
# define ASSERT_GUEST_MSG_STMT_RETURN_VOID(a_Expr, a, a_Stmt) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            a_Stmt; \
            return; \
        } \
    } while (0)
#endif


/** @def ASSERT_GUEST_MSG_BREAK
 * Assert that an expression is true and breaks if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before returning.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_BREAK(a_Expr, a) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        RTAssertMsg2Weak a; \
        ASSERT_GUEST_PANIC(); \
        break; \
    } else \
        break
#else
# define ASSERT_GUEST_MSG_BREAK(a_Expr, a) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else \
        break
#endif

/** @def ASSERT_GUEST_MSG_STMT_BREAK
 * Assert that an expression is true and breaks if it isn't.
 * In VBOX_STRICT_GUEST mode it will hit a breakpoint before doing break.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before break in case of a failed assertion.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_STMT_BREAK(a_Expr, a, a_Stmt) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        RTAssertMsg2Weak a; \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else \
        break
#else
# define ASSERT_GUEST_MSG_STMT_BREAK(a_Expr, a, a_Stmt) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        a_Stmt; \
        break; \
    } else \
        break
#endif

/** @def ASSERT_GUEST_FAILED
 * An assertion failed, hit breakpoint.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED()  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
    } while (0)
#else
# define ASSERT_GUEST_FAILED()         do { } while (0)
#endif

/** @def ASSERT_GUEST_FAILED_STMT
 * An assertion failed, hit breakpoint and execute statement.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED_STMT(a_Stmt) \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
    } while (0)
#else
# define ASSERT_GUEST_FAILED_STMT(a_Stmt)     do { a_Stmt; } while (0)
#endif

/** @def ASSERT_GUEST_FAILED_RETURN
 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only) and return.
 *
 * @param   a_rc    The a_rc to return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED_RETURN(a_rc)  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        return (a_rc); \
    } while (0)
#else
# define ASSERT_GUEST_FAILED_RETURN(a_rc)  \
    do { \
        return (a_rc); \
    } while (0)
#endif

/** @def ASSERT_GUEST_FAILED_STMT_RETURN
 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute a
 * statement and return a value.
 *
 * @param   a_Stmt  The statement to execute before returning.
 * @param   a_rc    The value to return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED_STMT_RETURN(a_Stmt, a_rc)  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        return (a_rc); \
    } while (0)
#else
# define ASSERT_GUEST_FAILED_STMT_RETURN(a_Stmt, a_rc)  \
    do { \
        a_Stmt; \
        return (a_rc); \
    } while (0)
#endif

/** @def ASSERT_GUEST_FAILED_RETURN_VOID
 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only) and return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED_RETURN_VOID()  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        return; \
    } while (0)
#else
# define ASSERT_GUEST_FAILED_RETURN_VOID()  \
    do { \
        return; \
    } while (0)
#endif

/** @def ASSERT_GUEST_FAILED_STMT_RETURN_VOID
 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute a
 * statement and return.
 *
 * @param a_Stmt The statement to execute before returning.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED_STMT_RETURN_VOID(a_Stmt)  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        return; \
    } while (0)
#else
# define ASSERT_GUEST_FAILED_STMT_RETURN_VOID(a_Stmt)  \
    do { \
        a_Stmt; \
        return; \
    } while (0)
#endif


/** @def ASSERT_GUEST_FAILED_BREAK
 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only) and break.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED_BREAK()  \
    if (1) { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        break; \
    } else \
        break
#else
# define ASSERT_GUEST_FAILED_BREAK()  \
    if (1) \
        break; \
    else \
        break
#endif

/** @def ASSERT_GUEST_FAILED_STMT_BREAK
 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute
 * the given statement and break.
 *
 * @param   a_Stmt  Statement to execute before break.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_FAILED_STMT_BREAK(a_Stmt) \
    if (1) { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else \
        break
#else
# define ASSERT_GUEST_FAILED_STMT_BREAK(a_Stmt) \
    if (1) { \
        a_Stmt; \
        break; \
    } else \
        break
#endif


/** @def ASSERT_GUEST_MSG_FAILED
 * An assertion failed print a message and a hit breakpoint.
 *
 * @param   a   printf argument list (in parenthesis).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_FAILED(a)  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
        RTAssertMsg2Weak a; \
        ASSERT_GUEST_PANIC(); \
    } while (0)
#else
# define ASSERT_GUEST_MSG_FAILED(a)     do { } while (0)
#endif

/** @def ASSERT_GUEST_MSG_FAILED_RETURN
 * An assertion failed, hit breakpoint with message (VBOX_STRICT_GUEST mode only) and return.
 *
 * @param   a       printf argument list (in parenthesis).
 * @param   a_rc    What is to be presented to return.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_FAILED_RETURN(a, a_rc)  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        RTAssertMsg2Weak a; \
        ASSERT_GUEST_PANIC(); \
        return (a_rc); \
    } while (0)
#else
# define ASSERT_GUEST_MSG_FAILED_RETURN(a, a_rc)  \
    do { \
        return (a_rc); \
    } while (0)
#endif

/** @def ASSERT_GUEST_MSG_FAILED_RETURN_VOID
 * An assertion failed, hit breakpoint with message (VBOX_STRICT_GUEST mode only) and return.
 *
 * @param   a       printf argument list (in parenthesis).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_FAILED_RETURN_VOID(a)  \
    do { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        RTAssertMsg2Weak a; \
        ASSERT_GUEST_PANIC(); \
        return; \
    } while (0)
#else
# define ASSERT_GUEST_MSG_FAILED_RETURN_VOID(a)  \
    do { \
        return; \
    } while (0)
#endif


/** @def ASSERT_GUEST_MSG_FAILED_BREAK
 * An assertion failed, hit breakpoint with message (VBOX_STRICT_GUEST mode only) and break.
 *
 * @param   a       printf argument list (in parenthesis).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_FAILED_BREAK(a)  \
    if (1) { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        RTAssertMsg2Weak a; \
        ASSERT_GUEST_PANIC(); \
        break; \
    } else \
        break
#else
# define ASSERT_GUEST_MSG_FAILED_BREAK(a)  \
    if (1) \
        break; \
    else \
        break
#endif

/** @def ASSERT_GUEST_MSG_FAILED_STMT_BREAK
 * An assertion failed, hit breakpoint (VBOX_STRICT_GUEST mode only), execute
 * the given statement and break.
 *
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before break.
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_MSG_FAILED_STMT_BREAK(a, a_Stmt) \
    if (1) { \
        ASSERT_GUEST_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        RTAssertMsg2Weak a; \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else \
        break
#else
# define ASSERT_GUEST_MSG_FAILED_STMT_BREAK(a, a_Stmt) \
    if (1) { \
        a_Stmt; \
        break; \
    } else \
        break
#endif

/** @} */



/** @name Guest input release log assertions
 *
 * These assertions will work like normal strict assertion when VBOX_STRICT_GUEST is
 * defined and LogRel statements when VBOX_STRICT_GUEST is undefined.  Typically
 * used for important guest input that it would be helpful to find in VBox.log
 * if the guest doesn't get it right.
 *
 * @{
 */


/** @def ASSERT_GUEST_LOGREL_MSG1
 * RTAssertMsg1Weak (strict builds) / LogRel wrapper (non-strict).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_LOGREL_MSG1(szExpr, iLine, pszFile, pszFunction) \
    RTAssertMsg1Weak("guest-input: " szExpr, iLine, pszFile, pszFunction)
#else
# define ASSERT_GUEST_LOGREL_MSG1(szExpr, iLine, pszFile, pszFunction) \
    LogRel(("ASSERT_GUEST_LOGREL %s(%d) %s: %s\n", (pszFile), (iLine), (pszFunction), (szExpr) ))
#endif

/** @def ASSERT_GUEST_LOGREL_MSG2
 * RTAssertMsg2Weak (strict builds) / LogRel wrapper (non-strict).
 */
#ifdef VBOX_STRICT_GUEST
# define ASSERT_GUEST_LOGREL_MSG2(a)  RTAssertMsg2Weak a
#else
# define ASSERT_GUEST_LOGREL_MSG2(a)  LogRel(a)
#endif

/** @def ASSERT_GUEST_LOGREL
 * Assert that an expression is true.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 */
#define ASSERT_GUEST_LOGREL(a_Expr) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_RETURN
 * Assert that an expression is true, return \a a_rc if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a_rc    What is to be presented to return.
 */
#define ASSERT_GUEST_LOGREL_RETURN(a_Expr, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
            return (a_rc); \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_RETURN_VOID
 * Assert that an expression is true, return void if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 */
#define ASSERT_GUEST_LOGREL_RETURN_VOID(a_Expr) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else \
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_PANIC(); \
            return; \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_BREAK
 * Assert that an expression is true, break if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 */
#define ASSERT_GUEST_LOGREL_BREAK(a_Expr) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        break; \
    } \
    else \
        break

/** @def ASSERT_GUEST_LOGREL_STMT_BREAK
 * Assert that an expression is true, execute \a a_Stmt and break if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a_Stmt  Statement to execute before break in case of a failed assertion.
 */
#define ASSERT_GUEST_LOGREL_STMT_BREAK(a_Expr, a_Stmt) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else \
        break

/** @def ASSERT_GUEST_LOGREL_MSG
 * Assert that an expression is true.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 */
#define ASSERT_GUEST_LOGREL_MSG(a_Expr, a) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else\
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_LOGREL_MSG2(a); \
            ASSERT_GUEST_PANIC(); \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_STMT
 * Assert that an expression is true, execute \a a_Stmt and break if it isn't
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute in case of a failed assertion.
 */
#define ASSERT_GUEST_LOGREL_MSG_STMT(a_Expr, a, a_Stmt) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else\
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_LOGREL_MSG2(a); \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RETURN
 * Assert that an expression is true, return \a a_rc if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_rc    What is to be presented to return.
 */
#define ASSERT_GUEST_LOGREL_MSG_RETURN(a_Expr, a, a_rc) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else\
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_LOGREL_MSG2(a); \
            ASSERT_GUEST_PANIC(); \
            return (a_rc); \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_STMT_RETURN
 * Assert that an expression is true, execute @a a_Stmt and return @a rcRet if it
 * isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before returning in case of a failed
 *                  assertion.
 * @param   rcRet   What is to be presented to return.
 */
#define ASSERT_GUEST_LOGREL_MSG_STMT_RETURN(a_Expr, a, a_Stmt, rcRet) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else\
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_LOGREL_MSG2(a); \
            ASSERT_GUEST_PANIC(); \
            a_Stmt; \
            return (rcRet); \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RETURN_VOID
 * Assert that an expression is true, return (void) if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 */
#define ASSERT_GUEST_LOGREL_MSG_RETURN_VOID(a_Expr, a) \
    do { \
        if (RT_LIKELY(!!(a_Expr))) \
        { /* likely */ } \
        else\
        { \
            ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
            ASSERT_GUEST_LOGREL_MSG2(a); \
            ASSERT_GUEST_PANIC(); \
            return; \
        } \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_BREAK
 * Assert that an expression is true, break if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 */
#define ASSERT_GUEST_LOGREL_MSG_BREAK(a_Expr, a) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        break; \
    } \
    else \
        break

/** @def ASSERT_GUEST_LOGREL_MSG_STMT_BREAK
 * Assert that an expression is true, execute \a a_Stmt and break if it isn't.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Expr  Expression which should be true.
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before break in case of a failed assertion.
 */
#define ASSERT_GUEST_LOGREL_MSG_STMT_BREAK(a_Expr, a, a_Stmt) \
    if (RT_LIKELY(!!(a_Expr))) \
    { /* likely */ } \
    else if (1) \
    { \
        ASSERT_GUEST_LOGREL_MSG1(#a_Expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else \
        break

/** @def ASSERT_GUEST_LOGREL_FAILED
 * An assertion failed.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 */
#define ASSERT_GUEST_LOGREL_FAILED() \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_FAILED_RETURN
 * An assertion failed.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_rc    What is to be presented to return.
 */
#define ASSERT_GUEST_LOGREL_FAILED_RETURN(a_rc) \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        return (a_rc); \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_FAILED_RETURN_VOID
 * An assertion failed, hit a breakpoint and return.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 */
#define ASSERT_GUEST_LOGREL_FAILED_RETURN_VOID() \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        return; \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_FAILED_BREAK
 * An assertion failed, break.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 */
#define ASSERT_GUEST_LOGREL_FAILED_BREAK() \
    if (1) \
    { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        break; \
    } else \
        break

/** @def ASSERT_GUEST_LOGREL_FAILED_STMT_BREAK
 * An assertion failed, execute \a a_Stmt and break.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a_Stmt  Statement to execute before break.
 */
#define ASSERT_GUEST_LOGREL_FAILED_STMT_BREAK(a_Stmt) \
    if (1) \
    { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else \
        break

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED
 * An assertion failed.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a   printf argument list (in parenthesis).
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED(a) \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT
 * An assertion failed, execute @a a_Stmt.
 *
 * Strict builds will hit a breakpoint, non-strict will only do LogRel. The
 * statement will be executed in regardless of build type.
 *
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute after raising/logging the assertion.
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT(a, a_Stmt) \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN
 * An assertion failed, return \a a_rc.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a   printf argument list (in parenthesis).
 * @param   a_rc  What is to be presented to return.
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN(a, a_rc) \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        return (a_rc); \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN
 * An assertion failed, execute @a a_Stmt and return @a a_rc.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before returning in case of a failed
 *                  assertion.
 * @param   a_rc    What is to be presented to return.
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN(a, a_Stmt, a_rc) \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        return (a_rc); \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN_VOID
 * An assertion failed, return void.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a   printf argument list (in parenthesis).
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED_RETURN_VOID(a) \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        return; \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN_VOID
 * An assertion failed, execute @a a_Stmt and return void.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a       printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before returning in case of a failed
 *                  assertion.
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_RETURN_VOID(a, a_Stmt) \
    do { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        return; \
    } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_BREAK
 * An assertion failed, break.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a   printf argument list (in parenthesis).
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED_BREAK(a) \
    if (1)\
    { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        break; \
    } else \
        break

/** @def ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_BREAK
 * An assertion failed, execute \a a_Stmt and break.
 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
 *
 * @param   a   printf argument list (in parenthesis).
 * @param   a_Stmt  Statement to execute before break.
 */
#define ASSERT_GUEST_LOGREL_MSG_FAILED_STMT_BREAK(a, a_Stmt) \
    if (1) \
    { \
        ASSERT_GUEST_LOGREL_MSG1("failed", __LINE__, __FILE__, __PRETTY_FUNCTION__); \
        ASSERT_GUEST_LOGREL_MSG2(a); \
        ASSERT_GUEST_PANIC(); \
        a_Stmt; \
        break; \
    } else \
        break

/** @} */


/** @name Convenience Assertions Macros
 * @{
 */

/** @def ASSERT_GUEST_RC
 * Asserts a iprt status code successful.
 *
 * On failure it will print info about the rc and hit a breakpoint.
 *
 * @param   rc  iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC(rc)                         ASSERT_GUEST_MSG_RC(rc, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_RC_STMT
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and execute
 * @a stmt if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_STMT(rc, stmt)              ASSERT_GUEST_MSG_RC_STMT(rc, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_RC_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_RETURN(rc, rcRet)           ASSERT_GUEST_MSG_RC_RETURN(rc, ("%Rra\n", (rc)), rcRet)

/** @def ASSERT_GUEST_RC_STMT_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and returns @a rcRet if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_STMT_RETURN(rc, stmt, rcRet) ASSERT_GUEST_MSG_RC_STMT_RETURN(rc, ("%Rra\n", (rc)), stmt, rcRet)

/** @def ASSERT_GUEST_RC_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_RETURN_VOID(rc)             ASSERT_GUEST_MSG_RC_RETURN_VOID(rc, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_RC_STMT_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
 * execute the given statement/return if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before returning on failure.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_STMT_RETURN_VOID(rc, stmt)  ASSERT_GUEST_MSG_RC_STMT_RETURN_VOID(rc, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_RC_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_BREAK(rc)                   ASSERT_GUEST_MSG_RC_BREAK(rc, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_RC_STMT_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_STMT_BREAK(rc, stmt)        ASSERT_GUEST_MSG_RC_STMT_BREAK(rc, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_MSG_RC
 * Asserts a iprt status code successful.
 *
 * It prints a custom message and hits a breakpoint on FAILURE.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC(rc, msg) \
    do { ASSERT_GUEST_MSG(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_MSG_RC_STMT
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and
 * execute @a stmt if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC_STMT(rc, msg, stmt) \
    do {   ASSERT_GUEST_MSG_STMT(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_MSG_RC_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
 * @a rcRet if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC_RETURN(rc, msg, rcRet) \
    do {   ASSERT_GUEST_MSG_RETURN(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_MSG_RC_STMT_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and return @a rcRet if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC_STMT_RETURN(rc, msg, stmt, rcRet) \
    do {   ASSERT_GUEST_MSG_STMT_RETURN(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_MSG_RC_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
 * void if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC_RETURN_VOID(rc, msg) \
    do {   ASSERT_GUEST_MSG_RETURN_VOID(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_MSG_RC_STMT_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and return void if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC_STMT_RETURN_VOID(rc, msg, stmt) \
    do {   ASSERT_GUEST_MSG_STMT_RETURN_VOID(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_MSG_RC_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break
 * if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC_BREAK(rc, msg) \
    if (1) { ASSERT_GUEST_MSG_BREAK(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)

/** @def ASSERT_GUEST_MSG_RC_STMT_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_MSG_RC_STMT_BREAK(rc, msg, stmt) \
    if (1) { ASSERT_GUEST_MSG_STMT_BREAK(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)

/** @def ASSERT_GUEST_RC_SUCCESS
 * Asserts an iprt status code equals VINF_SUCCESS.
 *
 * On failure it will print info about the rc and hit a breakpoint.
 *
 * @param   rc  iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_SUCCESS(rc)                 do { ASSERT_GUEST_MSG((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_RC_SUCCESS_RETURN
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_SUCCESS_RETURN(rc, rcRet)   ASSERT_GUEST_MSG_RETURN((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)

/** @def ASSERT_GUEST_RC_SUCCESS_RETURN_VOID
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_SUCCESS_RETURN_VOID(rc)     ASSERT_GUEST_MSG_RETURN_VOID((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_RC_SUCCESS_BREAK
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_SUCCESS_BREAK(rc)            ASSERT_GUEST_MSG_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_RC_SUCCESS_STMT_BREAK
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_RC_SUCCESS_STMT_BREAK(rc, stmt) ASSERT_GUEST_MSG_STMT_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_GCPHYS32
 * Asserts that the high dword of a physical address is zero
 *
 * @param   GCPhys      The address (RTGCPHYS).
 */
#define ASSERT_GUEST_GCPHYS32(GCPhys)               ASSERT_GUEST_MSG(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))


/** @def ASSERT_GUEST_RC
 * Asserts a iprt status code successful.
 *
 * On failure it will print info about the rc and hit a breakpoint.
 *
 * @param   rc  iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC(rc)                         ASSERT_GUEST_LOGREL_MSG_RC(rc, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_LOGREL_RC_STMT
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and execute
 * @a stmt if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_STMT(rc, stmt)              ASSERT_GUEST_LOGREL_MSG_RC_STMT(rc, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_LOGREL_RC_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_RETURN(rc, rcRet)           ASSERT_GUEST_LOGREL_MSG_RC_RETURN(rc, ("%Rra\n", (rc)), rcRet)

/** @def ASSERT_GUEST_LOGREL_RC_STMT_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and returns @a rcRet if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_STMT_RETURN(rc, stmt, rcRet) ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN(rc, ("%Rra\n", (rc)), stmt, rcRet)

/** @def ASSERT_GUEST_LOGREL_RC_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_RETURN_VOID(rc)             ASSERT_GUEST_LOGREL_MSG_RC_RETURN_VOID(rc, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_LOGREL_RC_STMT_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
 * execute the given statement/return if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before returning on failure.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_STMT_RETURN_VOID(rc, stmt)  ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN_VOID(rc, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_LOGREL_RC_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_BREAK(rc)                   ASSERT_GUEST_LOGREL_MSG_RC_BREAK(rc, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_LOGREL_RC_STMT_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_STMT_BREAK(rc, stmt)        ASSERT_GUEST_LOGREL_MSG_RC_STMT_BREAK(rc, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_LOGREL_MSG_RC
 * Asserts a iprt status code successful.
 *
 * It prints a custom message and hits a breakpoint on FAILURE.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC(rc, msg) \
    do { ASSERT_GUEST_LOGREL_MSG(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and
 * execute @a stmt if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC_STMT(rc, msg, stmt) \
    do {   ASSERT_GUEST_LOGREL_MSG_STMT(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RC_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
 * @a rcRet if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC_RETURN(rc, msg, rcRet) \
    do {   ASSERT_GUEST_LOGREL_MSG_RETURN(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and return @a rcRet if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before returning in case of a failed
 *                  assertion.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN(rc, msg, stmt, rcRet) \
    do {   ASSERT_GUEST_LOGREL_MSG_STMT_RETURN(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RC_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
 * void if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC_RETURN_VOID(rc, msg) \
    do {   ASSERT_GUEST_LOGREL_MSG_RETURN_VOID(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN_VOID
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and return void if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC_STMT_RETURN_VOID(rc, msg, stmt) \
    do {   ASSERT_GUEST_LOGREL_MSG_STMT_RETURN_VOID(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RC_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break
 * if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC_BREAK(rc, msg) \
    if (1) { ASSERT_GUEST_LOGREL_MSG_BREAK(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)

/** @def ASSERT_GUEST_LOGREL_MSG_RC_STMT_BREAK
 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
 * @a stmt and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   msg     printf argument list (in parenthesis).
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_MSG_RC_STMT_BREAK(rc, msg, stmt) \
    if (1) { ASSERT_GUEST_LOGREL_MSG_STMT_BREAK(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)

/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS
 * Asserts an iprt status code equals VINF_SUCCESS.
 *
 * On failure it will print info about the rc and hit a breakpoint.
 *
 * @param   rc  iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_SUCCESS(rc)                 do { ASSERT_GUEST_LOGREL_MSG((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)

/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   rcRet   What is to be presented to return.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN(rc, rcRet)   ASSERT_GUEST_LOGREL_MSG_RETURN((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)

/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN_VOID
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_SUCCESS_RETURN_VOID(rc)     ASSERT_GUEST_LOGREL_MSG_RETURN_VOID((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_BREAK
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_SUCCESS_BREAK(rc)            ASSERT_GUEST_LOGREL_MSG_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))

/** @def ASSERT_GUEST_LOGREL_RC_SUCCESS_STMT_BREAK
 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
 *
 * @param   rc      iprt status code.
 * @param   stmt    Statement to execute before break in case of a failed assertion.
 * @remark  rc is referenced multiple times. In release mode is NOREF()'ed.
 */
#define ASSERT_GUEST_LOGREL_RC_SUCCESS_STMT_BREAK(rc, stmt) ASSERT_GUEST_LOGREL_MSG_STMT_BREAK((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)

/** @def ASSERT_GUEST_LOGREL_GCPHYS32
 * Asserts that the high dword of a physical address is zero
 *
 * @param   GCPhys      The address (RTGCPHYS).
 */
#define ASSERT_GUEST_LOGREL_GCPHYS32(GCPhys)               ASSERT_GUEST_LOGREL_MSG(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))


/** @} */


/** @} */

#endif /* !VBOX_INCLUDED_AssertGuest_h */