VirtualBox

Changeset 96447 in vbox


Ignore:
Timestamp:
Aug 23, 2022 10:34:59 PM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
153291
Message:
iprt/assert.h: Added checks for RT_STRICT
!RTASSERT_NO_RELEASE_ASSERTIONS around release assertions, so it is possible to disable those too if needed. bugref:10261
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/assert.h

    r96407 r96447  
    15981598 * used to bail out before taking down the system (the VMMR0 case).
    15991599 */
    1600 #define RTAssertReleasePanic()   do { RTAssertShouldPanic(); RTAssertDoPanic(); } while (0)
     1600#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1601# define RTAssertReleasePanic()  do { RTAssertShouldPanic(); RTAssertDoPanic(); } while (0)
     1602#else
     1603# define RTAssertReleasePanic()  do { } while (0)
     1604#endif
    16011605
    16021606
    … …  
    16061610 * @param   expr    Expression which should be true.
    16071611 */
    1608 #define AssertRelease(expr)  \
     1612#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1613# define AssertRelease(expr)  \
    16091614    do { \
    16101615        if (RT_LIKELY(!!(expr))) \
    … …  
    16161621        } \
    16171622    } while (0)
     1623#else
     1624# define AssertRelease(expr)  do { } while (0)
     1625#endif
     1626
    16181627
    16191628/** @def AssertReleaseReturn
    … …  
    16231632 * @param   rc      What is to be presented to return.
    16241633 */
    1625 #define AssertReleaseReturn(expr, rc)  \
     1634#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1635# define AssertReleaseReturn(expr, rc)  \
    16261636    do { \
    16271637        if (RT_LIKELY(!!(expr))) \
    … …  
    16341644        } \
    16351645    } while (0)
     1646#else
     1647# define AssertReleaseReturn(expr, rc) \
     1648    do { \
     1649        if (RT_LIKELY(!!(expr))) \
     1650        { /* likely */ } \
     1651        else \
     1652            return (rc); \
     1653    } while (0)
     1654#endif
    16361655
    16371656/** @def AssertReleaseReturnVoid
    … …  
    16401659 * @param   expr    Expression which should be true.
    16411660 */
    1642 #define AssertReleaseReturnVoid(expr)  \
     1661#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1662# define AssertReleaseReturnVoid(expr)  \
    16431663    do { \
    16441664        if (RT_LIKELY(!!(expr))) \
    … …  
    16511671        } \
    16521672    } while (0)
     1673#else
     1674# define AssertReleaseReturnVoid(expr)  \
     1675    do { \
     1676        if (RT_LIKELY(!!(expr))) \
     1677        { /* likely */ } \
     1678        else \
     1679            return; \
     1680    } while (0)
     1681#endif
    16531682
    16541683
    … …  
    16581687 * @param   expr    Expression which should be true.
    16591688 */
    1660 #define AssertReleaseBreak(expr)  \
     1689#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1690# define AssertReleaseBreak(expr)  \
    16611691    if (RT_LIKELY(!!(expr))) \
    16621692    { /* likely */ } \
    … …  
    16681698    } else \
    16691699        break
     1700#else
     1701# define AssertReleaseBreak(expr)  \
     1702    if (RT_LIKELY(!!(expr))) \
     1703    { /* likely */ } \
     1704    else \
     1705        break
     1706#endif
    16701707
    16711708/** @def AssertReleaseBreakStmt
    … …  
    16751712 * @param   stmt    Statement to execute before break in case of a failed assertion.
    16761713 */
    1677 #define AssertReleaseBreakStmt(expr, stmt)  \
     1714#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1715# define AssertReleaseBreakStmt(expr, stmt)  \
    16781716    if (RT_LIKELY(!!(expr))) \
    16791717    { /* likely */ } \
    … …  
    16861724    } else \
    16871725        break
     1726#else
     1727# define AssertReleaseBreakStmt(expr, stmt)  \
     1728    if (RT_LIKELY(!!(expr))) \
     1729    { /* likely */ } \
     1730    else if (1) \
     1731    { \
     1732        stmt; \
     1733        break; \
     1734    } else \
     1735        break
     1736#endif
    16881737
    16891738
    … …  
    16941743 * @param   a       printf argument list (in parenthesis).
    16951744 */
    1696 #define AssertReleaseMsg(expr, a)  \
     1745#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1746# define AssertReleaseMsg(expr, a)  \
    16971747    do { \
    16981748        if (RT_LIKELY(!!(expr))) \
    … …  
    17051755        } \
    17061756    } while (0)
     1757#else
     1758# define AssertReleaseMsg(expr, a) do { } while (0)
     1759#endif
    17071760
    17081761/** @def AssertReleaseMsgReturn
    … …  
    17131766 * @param   rc      What is to be presented to return.
    17141767 */
    1715 #define AssertReleaseMsgReturn(expr, a, rc)  \
     1768#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1769# define AssertReleaseMsgReturn(expr, a, rc)  \
    17161770    do { \
    17171771        if (RT_LIKELY(!!(expr))) \
    … …  
    17251779        } \
    17261780    } while (0)
     1781#else
     1782# define AssertReleaseMsgReturn(expr, a, rc)  \
     1783    do { \
     1784        if (RT_LIKELY(!!(expr))) \
     1785        { /* likely */ } \
     1786        else \
     1787            return (rc); \
     1788    } while (0)
     1789#endif
    17271790
    17281791/** @def AssertReleaseMsgReturnVoid
    … …  
    17321795 * @param   a       printf argument list (in parenthesis).
    17331796 */
    1734 #define AssertReleaseMsgReturnVoid(expr, a)  \
     1797#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1798# define AssertReleaseMsgReturnVoid(expr, a)  \
    17351799    do { \
    17361800        if (RT_LIKELY(!!(expr))) \
    … …  
    17441808        } \
    17451809    } while (0)
     1810#else
     1811# define AssertReleaseMsgReturnVoid(expr, a)  \
     1812    do { \
     1813        if (RT_LIKELY(!!(expr))) \
     1814        { /* likely */ } \
     1815        else \
     1816            return; \
     1817    } while (0)
     1818#endif
    17461819
    17471820
    … …  
    17521825 * @param   a       printf argument list (in parenthesis).
    17531826 */
    1754 #define AssertReleaseMsgBreak(expr, a)  \
     1827#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1828# define AssertReleaseMsgBreak(expr, a)  \
    17551829    if (RT_LIKELY(!!(expr))) \
    17561830    { /* likely */ } \
    … …  
    17631837    } else \
    17641838        break
     1839#else
     1840# define AssertReleaseMsgBreak(expr, a)  \
     1841    if (RT_LIKELY(!!(expr))) \
     1842    { /* likely */ } \
     1843    else if (1) \
     1844        break; \
     1845    else \
     1846        break
     1847#endif
    17651848
    17661849/** @def AssertReleaseMsgBreakStmt
    … …  
    17711854 * @param   stmt    Statement to execute before break in case of a failed assertion.
    17721855 */
    1773 #define AssertReleaseMsgBreakStmt(expr, a, stmt)  \
     1856#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1857# define AssertReleaseMsgBreakStmt(expr, a, stmt)  \
    17741858    if (RT_LIKELY(!!(expr))) \
    17751859    { /* likely */ } \
    … …  
    17831867    } else \
    17841868        break
     1869#else
     1870# define AssertReleaseMsgBreakStmt(expr, a, stmt)  \
     1871    if (RT_LIKELY(!!(expr))) \
     1872    { /* likely */ } \
     1873    else if (1) \
     1874    { \
     1875        stmt; \
     1876        break; \
     1877    } else \
     1878        break
     1879#endif
    17851880
    17861881
    … …  
    17881883 * An assertion failed, hit a breakpoint.
    17891884 */
    1790 #define AssertReleaseFailed()  \
     1885#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1886# define AssertReleaseFailed()  \
    17911887    do { \
    17921888        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    17931889        RTAssertReleasePanic(); \
    17941890    } while (0)
     1891#else
     1892# define AssertReleaseFailed() do { } while (0)
     1893#endif
    17951894
    17961895/** @def AssertReleaseFailedReturn
    … …  
    17991898 * @param   rc      What is to be presented to return.
    18001899 */
    1801 #define AssertReleaseFailedReturn(rc)  \
     1900#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1901# define AssertReleaseFailedReturn(rc)  \
    18021902    do { \
    18031903        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18051905        return (rc); \
    18061906    } while (0)
     1907#else
     1908# define AssertReleaseFailedReturn(rc)  \
     1909    do { return (rc); } while (0)
     1910#endif
    18071911
    18081912/** @def AssertReleaseFailedReturnVoid
    18091913 * An assertion failed, hit a breakpoint and return.
    18101914 */
    1811 #define AssertReleaseFailedReturnVoid()  \
     1915#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1916# define AssertReleaseFailedReturnVoid()  \
    18121917    do { \
    18131918        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18151920        return; \
    18161921    } while (0)
    1817 
     1922#else
     1923# define AssertReleaseFailedReturnVoid()  \
     1924    do { return; } while (0)
     1925#endif
    18181926
    18191927/** @def AssertReleaseFailedBreak
    18201928 * An assertion failed, hit a breakpoint and break.
    18211929 */
    1822 #define AssertReleaseFailedBreak()  \
     1930#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1931# define AssertReleaseFailedBreak()  \
    18231932    if (1) { \
    18241933        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18271936    } else \
    18281937        break
     1938#else
     1939# define AssertReleaseFailedBreak()  \
     1940    if (1) \
     1941        break; \
     1942    else \
     1943        break
     1944#endif
    18291945
    18301946/** @def AssertReleaseFailedBreakStmt
    … …  
    18331949 * @param   stmt    Statement to execute before break.
    18341950 */
    1835 #define AssertReleaseFailedBreakStmt(stmt)  \
     1951#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1952# define AssertReleaseFailedBreakStmt(stmt)  \
    18361953    if (1) { \
    18371954        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18411958    } else \
    18421959        break
    1843 
     1960#else
     1961# define AssertReleaseFailedBreakStmt(stmt)  \
     1962    if (1) { \
     1963        stmt; \
     1964        break; \
     1965    } else \
     1966        break
     1967#endif
    18441968
    18451969/** @def AssertReleaseMsgFailed
    … …  
    18481972 * @param   a   printf argument list (in parenthesis).
    18491973 */
    1850 #define AssertReleaseMsgFailed(a)  \
     1974#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1975# define AssertReleaseMsgFailed(a)  \
    18511976    do { \
    18521977        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18541979        RTAssertReleasePanic(); \
    18551980    } while (0)
     1981#else
     1982# define AssertReleaseMsgFailed(a)  do { } while (0)
     1983#endif
    18561984
    18571985/** @def AssertReleaseMsgFailedReturn
    … …  
    18611989 * @param   rc      What is to be presented to return.
    18621990 */
    1863 #define AssertReleaseMsgFailedReturn(a, rc) \
     1991#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     1992# define AssertReleaseMsgFailedReturn(a, rc) \
    18641993    do { \
    18651994        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18681997        return (rc); \
    18691998    } while (0)
     1999#else
     2000# define AssertReleaseMsgFailedReturn(a, rc) \
     2001    do { return (rc); } while (0)
     2002#endif
    18702003
    18712004/** @def AssertReleaseMsgFailedReturnVoid
    … …  
    18742007 * @param   a   printf argument list (in parenthesis).
    18752008 */
    1876 #define AssertReleaseMsgFailedReturnVoid(a) \
     2009#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     2010# define AssertReleaseMsgFailedReturnVoid(a) \
    18772011    do { \
    18782012        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18812015        return; \
    18822016    } while (0)
     2017#else
     2018# define AssertReleaseMsgFailedReturnVoid(a) \
     2019    do { return; } while (0)
     2020#endif
    18832021
    18842022
    … …  
    18882026 * @param   a   printf argument list (in parenthesis).
    18892027 */
    1890 #define AssertReleaseMsgFailedBreak(a) \
     2028#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     2029# define AssertReleaseMsgFailedBreak(a) \
    18912030    if (1) { \
    18922031        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    18962035    } else \
    18972036        break
     2037#else
     2038# define AssertReleaseMsgFailedBreak(a) \
     2039    if (1) \
     2040        break; \
     2041    else \
     2042        break
     2043#endif
    18982044
    18992045/** @def AssertReleaseMsgFailedBreakStmt
    … …  
    19032049 * @param   stmt    Statement to execute before break.
    19042050 */
    1905 #define AssertReleaseMsgFailedBreakStmt(a, stmt) \
     2051#if defined(RT_STRICT) || !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
     2052# define AssertReleaseMsgFailedBreakStmt(a, stmt) \
    19062053    if (1) { \
    19072054        RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
    … …  
    19122059    } else \
    19132060        break
    1914 
     2061#else
     2062# define AssertReleaseMsgFailedBreakStmt(a, stmt) \
     2063    if (1) { \
     2064        stmt; \
     2065        break; \
     2066    } else \
     2067        break
     2068#endif
    19152069/** @} */
    19162070
Note: See TracChangeset for help on using the changeset viewer.

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