Index: /trunk/include/iprt/assert.h =================================================================== --- /trunk/include/iprt/assert.h (revision 30239) +++ /trunk/include/iprt/assert.h (revision 30240) @@ -273,9 +273,24 @@ #endif +/** @def RTASSERT_HAVE_STATIC_ASSERT + * Indicates that the compiler implements static_assert(expr, msg). + * @todo Does any GCC version support static_assert? + */ +#ifdef _MSC_VER +# if _MSC_VER >= 1600 && defined(__cplusplus) +# define RTASSERT_HAVE_STATIC_ASSERT +# endif +#endif +#ifdef DOXYGEN_RUNNING +# define RTASSERT_HAVE_STATIC_ASSERT +#endif + /** @def AssertCompile * Asserts that a compile-time expression is true. If it's not break the build. * @param expr Expression which should be true. */ -#ifdef __GNUC__ +#ifdef RTASSERT_HAVE_STATIC_ASSERT +# define AssertCompile(expr) static_assert(!!(expr), #expr) +#elif defined(__GNUC__) # define AssertCompile(expr) extern int RTASSERTVAR[1] __attribute__((unused)), RTASSERTVAR[(expr) ? 1 : 0] __attribute__((unused)) #else @@ -393,4 +408,55 @@ #endif +/** @def AssertCompileMembersAtSameOffset + * Asserts that members of two different structures are at the same offset. + * @param type1 The first type. + * @param member1 The first member. + * @param type2 The second type. + * @param member2 The second member. + */ +#if defined(__GNUC__) +# if __GNUC__ >= 4 +# define AssertCompileMembersAtSameOffset(type1, member1, type2, member2) \ + AssertCompile(__builtin_offsetof(type1, member1) == __builtin_offsetof(type2, member2)) +# else +# define AssertCompileMembersAtSameOffset(type1, member1, type2, member2) \ + AssertCompile(RT_OFFSETOF(type1, member1) == RT_OFFSETOF(type2, member2)) +# endif +#else +# define AssertCompileMembersAtSameOffset(type, member1, member2) \ + AssertCompile(RT_OFFSETOF(type1, member1) == RT_OFFSETOF(type2, member2)) +#endif + +/** @def AssertCompileMembersSameSize + * Asserts that members of two different structures have the same size. + * @param type1 The first type. + * @param member1 The first member. + * @param type2 The second type. + * @param member2 The second member. + */ +#define AssertCompileMembersSameSize(type1, member1, type2, member2) \ + AssertCompile(RT_SIZEOFMEMB(type1, member1) == RT_SIZEOFMEMB(type2, member2)) + +/** @def AssertCompileMembersSameSizeAndOffset + * Asserts that members of two different structures have the same size and are + * at the same offset. + * @param type1 The first type. + * @param member1 The first member. + * @param type2 The second type. + * @param member2 The second member. + */ +#if defined(__GNUC__) +# if __GNUC__ >= 4 +# define AssertCompileMembersSameSizeAndOffset(type1, member1, type2, member2) \ + AssertCompile(__builtin_offsetof(type1, member1) == __builtin_offsetof(type2, member2) && RT_SIZEOFMEMB(type1, member1) == RT_SIZEOFMEMB(type2, member2)) +# else +# define AssertCompileMembersSameSizeAndOffset(type1, member1, type2, member2) \ + AssertCompile(RT_OFFSETOF(type1, member1) == RT_OFFSETOF(type2, member2) && RT_SIZEOFMEMB(type1, member1) == RT_SIZEOFMEMB(type2, member2)) +# endif +#else +# define AssertCompileMembersSameSizeAndOffset(type, member1, member2) \ + AssertCompile(RT_OFFSETOF(type1, member1) == RT_OFFSETOF(type2, member2) && RT_SIZEOFMEMB(type1, member1) == RT_SIZEOFMEMB(type2, member2)) +#endif + /** @} */ Index: /trunk/src/VBox/Runtime/testcase/Makefile.kmk =================================================================== --- /trunk/src/VBox/Runtime/testcase/Makefile.kmk (revision 30239) +++ /trunk/src/VBox/Runtime/testcase/Makefile.kmk (revision 30240) @@ -45,4 +45,5 @@ # PROGRAMS += \ + tstRTAssertCompile \ tstRTAvl \ tstRTBase64 \ @@ -162,4 +163,8 @@ # +tstRTAssertCompile_TEMPLATE = VBOXR3TSTEXE +tstRTAssertCompile_NOINST = true +tstRTAssertCompile_SOURCES = tstRTAssertCompile.cpp + tstRTAvl_TEMPLATE = VBOXR3TSTEXE tstRTAvl_SOURCES = tstRTAvl.cpp Index: /trunk/src/VBox/Runtime/testcase/tstRTAssertCompile.cpp =================================================================== --- /trunk/src/VBox/Runtime/testcase/tstRTAssertCompile.cpp (revision 30240) +++ /trunk/src/VBox/Runtime/testcase/tstRTAssertCompile.cpp (revision 30240) @@ -0,0 +1,150 @@ +/* $Id$ */ +/** @file + * IPRT Testcase - AssertCompile* - A Compile Time Testcase. + */ + +/* + * Copyright (C) 2010 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE 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. + */ + + +/******************************************************************************* +* Header Files * +*******************************************************************************/ +#include + + +int main(int argc, char **argv) +{ + /* Only positive tests here. */ + + AssertCompile(true); + AssertCompile(1); + AssertCompile(2); + AssertCompile(99); + + uint8_t u8; NOREF( u8); + uint16_t u16; NOREF(u16); + uint32_t u32; NOREF(u32); + uint64_t u64; NOREF(u64); + AssertCompileSize( u8, 1); + AssertCompileSize(u16, 2); + AssertCompileSize(u32, 4); + AssertCompileSize(u64, 8); + + AssertCompileSizeAlignment( u8, 1); + AssertCompileSizeAlignment(u16, 1); + AssertCompileSizeAlignment(u16, 2); + AssertCompileSizeAlignment(u32, 1); + AssertCompileSizeAlignment(u32, 2); + AssertCompileSizeAlignment(u32, 4); + AssertCompileSizeAlignment(u64, 1); + AssertCompileSizeAlignment(u64, 2); + AssertCompileSizeAlignment(u64, 4); + AssertCompileSizeAlignment(u64, 8); + + typedef struct STRUCT1 + { + uint8_t u8; + uint8_t au8[8]; + uint64_t u64; + uint8_t u8UnalignmentFiller1; + uint32_t u32; + uint8_t u8UnalignmentFiller2; + uint16_t u16; + const char *psz; + uint32_t u32A; + uint32_t u32B; + } STRUCT1, STRUCT2; + + AssertCompileMemberSize(STRUCT1, u8, 1); + AssertCompileMemberSize(STRUCT1, u16, 2); + AssertCompileMemberSize(STRUCT1, u32, 4); + AssertCompileMemberSize(STRUCT1, u64, 8); + + AssertCompileMemberSizeAlignment(STRUCT1, u8, 1); + AssertCompileMemberSizeAlignment(STRUCT1, u16, 1); + AssertCompileMemberSizeAlignment(STRUCT1, u16, 2); + AssertCompileMemberSizeAlignment(STRUCT1, u32, 1); + AssertCompileMemberSizeAlignment(STRUCT1, u32, 2); + AssertCompileMemberSizeAlignment(STRUCT1, u32, 4); + AssertCompileMemberSizeAlignment(STRUCT1, u64, 1); + AssertCompileMemberSizeAlignment(STRUCT1, u64, 2); + AssertCompileMemberSizeAlignment(STRUCT1, u64, 4); + AssertCompileMemberSizeAlignment(STRUCT1, u64, 8); + AssertCompileMemberSizeAlignment(STRUCT1, psz, sizeof(void *)); + + AssertCompileMemberAlignment(STRUCT1, u8, 1); + AssertCompileMemberAlignment(STRUCT1, u16, 1); + AssertCompileMemberAlignment(STRUCT1, u16, 2); + AssertCompileMemberAlignment(STRUCT1, u32, 1); + AssertCompileMemberAlignment(STRUCT1, u32, 2); + AssertCompileMemberAlignment(STRUCT1, u32, 4); + AssertCompileMemberAlignment(STRUCT1, u64, 1); + AssertCompileMemberAlignment(STRUCT1, u64, 2); + AssertCompileMemberAlignment(STRUCT1, u64, 4); +#if defined(__GNUC__) && ARCH_BITS >= 64 + AssertCompileMemberAlignment(STRUCT1, u64, 8); +#endif + AssertCompileMemberAlignment(STRUCT1, psz, sizeof(void *)); + + AssertCompileMemberOffset(STRUCT1, u8, 0); + AssertCompileMemberOffset(STRUCT1, au8, 1); + AssertCompileMemberOffset(STRUCT1, au8[0], 1); + AssertCompileMemberOffset(STRUCT1, au8[8], 9); + + typedef union UNION1 + { + STRUCT1 s1; + STRUCT2 s2; + } UNION1; + + AssertCompile2MemberOffsets(UNION1, s1.u8, s2.u8); + AssertCompile2MemberOffsets(UNION1, s1.u16, s2.u16); + AssertCompile2MemberOffsets(UNION1, s1.u32, s2.u32); + AssertCompile2MemberOffsets(UNION1, s1.u64, s2.u64); + AssertCompile2MemberOffsets(UNION1, s1.psz, s2.psz); + + AssertCompileAdjacentMembers(STRUCT1, u32A, u32B); + AssertCompileAdjacentMembers(STRUCT1, u8, au8); + AssertCompileAdjacentMembers(STRUCT1, u8, au8[0]); + AssertCompileAdjacentMembers(STRUCT1, au8[0], au8[1]); + + AssertCompileMembersAtSameOffset(STRUCT1, u8, STRUCT2, u8); + AssertCompileMembersAtSameOffset(STRUCT1, au8, STRUCT2, au8); + AssertCompileMembersAtSameOffset(STRUCT1, u16, STRUCT2, u16); + AssertCompileMembersAtSameOffset(STRUCT1, u32, STRUCT2, u32); + AssertCompileMembersAtSameOffset(STRUCT1, u64, STRUCT2, u64); + + AssertCompileMembersSameSize(STRUCT1, u8, STRUCT2, u8); + AssertCompileMembersSameSize(STRUCT1, au8, STRUCT2, au8); + AssertCompileMembersSameSize(STRUCT1, u16, STRUCT2, u16); + AssertCompileMembersSameSize(STRUCT1, u32, STRUCT2, u32); + AssertCompileMembersSameSize(STRUCT1, u64, STRUCT2, u64); + + AssertCompileMembersSameSizeAndOffset(STRUCT1, u8, STRUCT2, u8); + AssertCompileMembersSameSizeAndOffset(STRUCT1, au8, STRUCT2, au8); + AssertCompileMembersSameSizeAndOffset(STRUCT1, u16, STRUCT2, u16); + AssertCompileMembersSameSizeAndOffset(STRUCT1, u32, STRUCT2, u32); + AssertCompileMembersSameSizeAndOffset(STRUCT1, u64, STRUCT2, u64); + + return 0; +} +