Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=i386-pc-win32 -verify -DVMB %s
      2 // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMB %s
      3 // RUN: %clang_cc1 -std=c++11 -fms-compatibility -fsyntax-only -triple=x86_64-pc-win32 -verify -DVMV -fms-memptr-rep=virtual %s
      4 //
      5 // This file should also give no diagnostics when run through cl.exe from MSVS
      6 // 2012, which supports C++11 and static_assert.  It should pass for both 64-bit
      7 // and 32-bit x86.
      8 //
      9 // Test the size of various member pointer combinations:
     10 // - complete and incomplete
     11 // - single, multiple, and virtual inheritance (and unspecified for incomplete)
     12 // - data and function pointers
     13 // - templated with declared specializations with annotations
     14 // - template that can be instantiated
     15 
     16 // http://llvm.org/PR12070
     17 struct Foo {
     18   typedef int Foo::*FooInt;
     19   int f;
     20 };
     21 
     22 #ifdef VMB
     23 enum {
     24   kSingleDataAlign             = 1 * sizeof(int),
     25   kSingleFunctionAlign         = 1 * sizeof(void *),
     26   kMultipleDataAlign           = 1 * sizeof(int),
     27   // Everything with more than 1 field is 8 byte aligned, except virtual data
     28   // member pointers on x64 (ugh).
     29   kMultipleFunctionAlign       = 8,
     30 #ifdef _M_X64
     31   kVirtualDataAlign            = 4,
     32 #else
     33   kVirtualDataAlign            = 8,
     34 #endif
     35   kVirtualFunctionAlign        = 8,
     36   kUnspecifiedDataAlign        = 8,
     37   kUnspecifiedFunctionAlign    = 8,
     38 
     39   kSingleDataSize             = 1 * sizeof(int),
     40   kSingleFunctionSize         = 1 * sizeof(void *),
     41   kMultipleDataSize           = 1 * sizeof(int),
     42   kMultipleFunctionSize       = 2 * sizeof(void *),
     43   kVirtualDataSize            = 2 * sizeof(int),
     44   kVirtualFunctionSize        = 2 * sizeof(int) + 1 * sizeof(void *),
     45   kUnspecifiedDataSize        = 3 * sizeof(int),
     46   kUnspecifiedFunctionSize    = 2 * sizeof(int) + 2 * sizeof(void *),
     47 };
     48 #elif VMV
     49 enum {
     50   // Everything with more than 1 field is 8 byte aligned, except virtual data
     51   // member pointers on x64 (ugh).
     52 #ifdef _M_X64
     53   kVirtualDataAlign = 4,
     54 #else
     55   kVirtualDataAlign = 8,
     56 #endif
     57   kMultipleDataAlign = kVirtualDataAlign,
     58   kSingleDataAlign = kVirtualDataAlign,
     59 
     60   kUnspecifiedFunctionAlign = 8,
     61   kVirtualFunctionAlign = kUnspecifiedFunctionAlign,
     62   kMultipleFunctionAlign = kUnspecifiedFunctionAlign,
     63   kSingleFunctionAlign = kUnspecifiedFunctionAlign,
     64 
     65   kUnspecifiedDataSize = 3 * sizeof(int),
     66   kVirtualDataSize = kUnspecifiedDataSize,
     67   kMultipleDataSize = kUnspecifiedDataSize,
     68   kSingleDataSize = kUnspecifiedDataSize,
     69 
     70   kUnspecifiedFunctionSize = 2 * sizeof(int) + 2 * sizeof(void *),
     71   kVirtualFunctionSize = kUnspecifiedFunctionSize,
     72   kMultipleFunctionSize = kUnspecifiedFunctionSize,
     73   kSingleFunctionSize = kUnspecifiedFunctionSize,
     74 };
     75 #else
     76 #error "test doesn't yet support this mode!"
     77 #endif
     78 
     79 // incomplete types
     80 #ifdef VMB
     81 class __single_inheritance IncSingle;
     82 class __multiple_inheritance IncMultiple;
     83 class __virtual_inheritance IncVirtual;
     84 #else
     85 class IncSingle;
     86 class IncMultiple;
     87 class IncVirtual;
     88 #endif
     89 static_assert(sizeof(int IncSingle::*)        == kSingleDataSize, "");
     90 static_assert(sizeof(int IncMultiple::*)      == kMultipleDataSize, "");
     91 static_assert(sizeof(int IncVirtual::*)       == kVirtualDataSize, "");
     92 static_assert(sizeof(void (IncSingle::*)())   == kSingleFunctionSize, "");
     93 static_assert(sizeof(void (IncMultiple::*)()) == kMultipleFunctionSize, "");
     94 static_assert(sizeof(void (IncVirtual::*)())  == kVirtualFunctionSize, "");
     95 
     96 static_assert(__alignof(int IncSingle::*)        == kSingleDataAlign, "");
     97 static_assert(__alignof(int IncMultiple::*)      == kMultipleDataAlign, "");
     98 static_assert(__alignof(int IncVirtual::*)       == kVirtualDataAlign, "");
     99 static_assert(__alignof(void (IncSingle::*)())   == kSingleFunctionAlign, "");
    100 static_assert(__alignof(void (IncMultiple::*)()) == kMultipleFunctionAlign, "");
    101 static_assert(__alignof(void (IncVirtual::*)())  == kVirtualFunctionAlign, "");
    102 
    103 // An incomplete type with an unspecified inheritance model seems to take one
    104 // more slot than virtual.  It's not clear what it's used for yet.
    105 class IncUnspecified;
    106 static_assert(sizeof(int IncUnspecified::*) == kUnspecifiedDataSize, "");
    107 static_assert(sizeof(void (IncUnspecified::*)()) == kUnspecifiedFunctionSize, "");
    108 
    109 // complete types
    110 struct B1 { };
    111 struct B2 { };
    112 struct Single { };
    113 struct Multiple : B1, B2 { };
    114 struct Virtual : virtual B1 { };
    115 static_assert(sizeof(int Single::*)        == kSingleDataSize, "");
    116 static_assert(sizeof(int Multiple::*)      == kMultipleDataSize, "");
    117 static_assert(sizeof(int Virtual::*)       == kVirtualDataSize, "");
    118 static_assert(sizeof(void (Single::*)())   == kSingleFunctionSize, "");
    119 static_assert(sizeof(void (Multiple::*)()) == kMultipleFunctionSize, "");
    120 static_assert(sizeof(void (Virtual::*)())  == kVirtualFunctionSize, "");
    121 
    122 // Test both declared and defined templates.
    123 template <typename T> class X;
    124 #ifdef VMB
    125 template <> class __single_inheritance   X<IncSingle>;
    126 template <> class __multiple_inheritance X<IncMultiple>;
    127 template <> class __virtual_inheritance  X<IncVirtual>;
    128 #else
    129 template <> class X<IncSingle>;
    130 template <> class X<IncMultiple>;
    131 template <> class X<IncVirtual>;
    132 #endif
    133 // Don't declare X<IncUnspecified>.
    134 static_assert(sizeof(int X<IncSingle>::*)           == kSingleDataSize, "");
    135 static_assert(sizeof(int X<IncMultiple>::*)         == kMultipleDataSize, "");
    136 static_assert(sizeof(int X<IncVirtual>::*)          == kVirtualDataSize, "");
    137 static_assert(sizeof(int X<IncUnspecified>::*)      == kUnspecifiedDataSize, "");
    138 static_assert(sizeof(void (X<IncSingle>::*)())      == kSingleFunctionSize, "");
    139 static_assert(sizeof(void (X<IncMultiple>::*)())    == kMultipleFunctionSize, "");
    140 static_assert(sizeof(void (X<IncVirtual>::*)())     == kVirtualFunctionSize, "");
    141 static_assert(sizeof(void (X<IncUnspecified>::*)()) == kUnspecifiedFunctionSize, "");
    142 
    143 template <typename T>
    144 struct Y : T { };
    145 static_assert(sizeof(int Y<Single>::*)        == kSingleDataSize, "");
    146 static_assert(sizeof(int Y<Multiple>::*)      == kMultipleDataSize, "");
    147 static_assert(sizeof(int Y<Virtual>::*)       == kVirtualDataSize, "");
    148 static_assert(sizeof(void (Y<Single>::*)())   == kSingleFunctionSize, "");
    149 static_assert(sizeof(void (Y<Multiple>::*)()) == kMultipleFunctionSize, "");
    150 static_assert(sizeof(void (Y<Virtual>::*)())  == kVirtualFunctionSize, "");
    151 
    152 struct A { int x; void bar(); };
    153 struct B : A { virtual void foo(); };
    154 static_assert(sizeof(int B::*) == kSingleDataSize, "");
    155 // A non-primary base class uses the multiple inheritance model for member
    156 // pointers.
    157 static_assert(sizeof(void (B::*)()) == kMultipleFunctionSize, "");
    158 
    159 struct AA { int x; virtual void foo(); };
    160 struct BB : AA { void bar(); };
    161 struct CC : BB { virtual void baz(); };
    162 static_assert(sizeof(void (CC::*)()) == kSingleFunctionSize, "");
    163 
    164 // We start out unspecified.
    165 struct ForwardDecl1;
    166 struct ForwardDecl2;
    167 
    168 // Re-declare to force us to iterate decls when adding attributes.
    169 struct ForwardDecl1;
    170 struct ForwardDecl2;
    171 
    172 typedef int ForwardDecl1::*MemPtr1;
    173 typedef int ForwardDecl2::*MemPtr2;
    174 MemPtr1 variable_forces_sizing;
    175 
    176 struct ForwardDecl1 : B {
    177   virtual void foo();
    178 };
    179 struct ForwardDecl2 : B {
    180   virtual void foo();
    181 };
    182 
    183 static_assert(sizeof(variable_forces_sizing) == kUnspecifiedDataSize, "");
    184 static_assert(sizeof(MemPtr1) == kUnspecifiedDataSize, "");
    185 static_assert(sizeof(MemPtr2) == kSingleDataSize, "");
    186 
    187 struct MemPtrInBody {
    188   typedef int MemPtrInBody::*MemPtr;
    189   int a;
    190   operator MemPtr() const {
    191     return a ? &MemPtrInBody::a : 0;
    192   }
    193 };
    194 
    195 static_assert(sizeof(MemPtrInBody::MemPtr) == kSingleDataSize, "");
    196 
    197 // Passing a member pointer through a template should get the right size.
    198 template<typename T>
    199 struct SingleTemplate;
    200 template<typename T>
    201 struct SingleTemplate<void (T::*)(void)> {
    202   static_assert(sizeof(int T::*) == kSingleDataSize, "");
    203   static_assert(sizeof(void (T::*)()) == kSingleFunctionSize, "");
    204 };
    205 
    206 template<typename T>
    207 struct UnspecTemplate;
    208 template<typename T>
    209 struct UnspecTemplate<void (T::*)(void)> {
    210   static_assert(sizeof(int T::*) == kUnspecifiedDataSize, "");
    211   static_assert(sizeof(void (T::*)()) == kUnspecifiedFunctionSize, "");
    212 };
    213 
    214 struct NewUnspecified;
    215 SingleTemplate<void (IncSingle::*)()> tmpl_single;
    216 UnspecTemplate<void (NewUnspecified::*)()> tmpl_unspec;
    217 
    218 struct NewUnspecified { };
    219 
    220 static_assert(sizeof(void (NewUnspecified::*)()) == kUnspecifiedFunctionSize, "");
    221 
    222 template <typename T>
    223 struct MemPtrInTemplate {
    224   // We can't require that the template arg be complete until we're
    225   // instantiated.
    226   int T::*data_ptr;
    227   void (T::*func_ptr)();
    228 };
    229 
    230 #ifdef VMB
    231 int Virtual::*CastTest = reinterpret_cast<int Virtual::*>(&AA::x);
    232   // expected-error@-1 {{cannot reinterpret_cast from member pointer type}}
    233 #endif
    234 
    235 namespace ErrorTest {
    236 template <typename T, typename U> struct __single_inheritance A;
    237   // expected-warning@-1 {{inheritance model ignored on primary template}}
    238 template <typename T> struct __multiple_inheritance A<T, T>;
    239   // expected-warning@-1 {{inheritance model ignored on partial specialization}}
    240 template <> struct __single_inheritance A<int, float>;
    241 
    242 struct B {}; // expected-note {{B defined here}}
    243 struct __multiple_inheritance B; // expected-error{{inheritance model does not match definition}}
    244 
    245 struct __multiple_inheritance C {}; // expected-error{{inheritance model does not match definition}}
    246  // expected-note@-1 {{C defined here}}
    247 
    248 struct __virtual_inheritance D;
    249 struct D : virtual B {};
    250 }
    251 #ifdef VMB
    252 #pragma pointers_to_members(full_generality, multiple_inheritance)
    253 struct TrulySingleInheritance;
    254 static_assert(sizeof(int TrulySingleInheritance::*) == kMultipleDataSize, "");
    255 #pragma pointers_to_members(best_case)
    256 // This definition shouldn't conflict with the increased generality that the
    257 // multiple_inheritance model gave to TrulySingleInheritance.
    258 struct TrulySingleInheritance {};
    259 
    260 // Even if a definition proceeds the first mention of a pointer to member, we
    261 // still give the record the fully general representation.
    262 #pragma pointers_to_members(full_generality, virtual_inheritance)
    263 struct SingleInheritanceAsVirtualAfterPragma {};
    264 static_assert(sizeof(int SingleInheritanceAsVirtualAfterPragma::*) == 12, "");
    265 
    266 #pragma pointers_to_members(best_case)
    267 
    268 // The above holds even if the pragma comes after the definition.
    269 struct SingleInheritanceAsVirtualBeforePragma {};
    270 #pragma pointers_to_members(virtual_inheritance)
    271 static_assert(sizeof(int SingleInheritanceAsVirtualBeforePragma::*) == 12, "");
    272 
    273 #pragma pointers_to_members(single) // expected-error{{unexpected 'single'}}
    274 #endif
    275