1 // RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -emit-llvm -O3 -o - | FileCheck %s 2 #include <typeinfo> 3 4 // vtables. 5 extern "C" { 6 const void *_ZTVN10__cxxabiv123__fundamental_type_infoE; 7 const void *_ZTVN10__cxxabiv117__class_type_infoE; 8 const void *_ZTVN10__cxxabiv120__si_class_type_infoE; 9 const void *_ZTVN10__cxxabiv121__vmi_class_type_infoE; 10 const void *_ZTVN10__cxxabiv119__pointer_type_infoE; 11 const void *_ZTVN10__cxxabiv129__pointer_to_member_type_infoE; 12 }; 13 #define fundamental_type_info_vtable _ZTVN10__cxxabiv123__fundamental_type_infoE 14 #define class_type_info_vtable _ZTVN10__cxxabiv117__class_type_infoE 15 #define si_class_type_info_vtable _ZTVN10__cxxabiv120__si_class_type_infoE 16 #define vmi_class_type_info_vtable _ZTVN10__cxxabiv121__vmi_class_type_infoE 17 #define pointer_type_info_vtable _ZTVN10__cxxabiv119__pointer_type_infoE 18 #define pointer_to_member_type_info_vtable _ZTVN10__cxxabiv129__pointer_to_member_type_infoE 19 20 class __pbase_type_info : public std::type_info { 21 public: 22 unsigned int __flags; 23 const std::type_info *__pointee; 24 25 enum __masks { 26 __const_mask = 0x1, 27 __volatile_mask = 0x2, 28 __restrict_mask = 0x4, 29 __incomplete_mask = 0x8, 30 __incomplete_class_mask = 0x10 31 }; 32 }; 33 34 class __class_type_info : public std::type_info { }; 35 36 class __si_class_type_info : public __class_type_info { 37 public: 38 const __class_type_info *__base_type; 39 }; 40 41 struct __base_class_type_info { 42 public: 43 const __class_type_info *__base_type; 44 long __offset_flags; 45 46 enum __offset_flags_masks { 47 __virtual_mask = 0x1, 48 __public_mask = 0x2, 49 __offset_shift = 8 50 }; 51 }; 52 53 class __vmi_class_type_info : public __class_type_info { 54 public: 55 unsigned int __flags; 56 unsigned int __base_count; 57 __base_class_type_info __base_info[1]; 58 59 enum __flags_masks { 60 __non_diamond_repeat_mask = 0x1, 61 __diamond_shaped_mask = 0x2 62 }; 63 }; 64 65 template<typename T> const T& to(const std::type_info &info) { 66 return static_cast<const T&>(info); 67 } 68 struct Incomplete; 69 70 struct A { int a; }; 71 struct Empty { }; 72 73 struct SI1 : A { }; 74 struct SI2 : Empty { }; 75 struct SI3 : Empty { virtual void f() { } }; 76 77 struct VMI1 : private A { }; 78 struct VMI2 : virtual A { }; 79 struct VMI3 : A { virtual void f() { } }; 80 struct VMI4 : A, Empty { }; 81 82 struct VMIBase1 { int a; }; 83 struct VMIBase2 : VMIBase1 { int a; }; 84 struct VMI5 : VMIBase1, VMIBase2 { int a; }; 85 86 struct VMIBase3 : virtual VMIBase1 { int a; }; 87 struct VMI6 : virtual VMIBase1, VMIBase3 { int a; }; 88 89 struct VMI7 : VMIBase1, VMI5, private VMI6 { }; 90 91 #define CHECK(x) if (!(x)) return __LINE__ 92 #define CHECK_VTABLE(type, vtable) CHECK(&vtable##_type_info_vtable + 2 == (((void **)&(typeid(type)))[0])) 93 #define CHECK_BASE_INFO_TYPE(type, index, base) CHECK(to<__vmi_class_type_info>(typeid(type)).__base_info[(index)].__base_type == &typeid(base)) 94 #define CHECK_BASE_INFO_OFFSET_FLAGS(type, index, offset, flags) CHECK(to<__vmi_class_type_info>(typeid(type)).__base_info[(index)].__offset_flags == (((offset) << 8) | (flags))) 95 96 struct B { 97 static int const volatile (*a)[10]; 98 static int (*b)[10]; 99 100 static int const volatile (B::*c)[10]; 101 static int (B::*d)[10]; 102 }; 103 104 // CHECK-LABEL: define i32 @_Z1fv() 105 int f() { 106 // Vectors should be treated as fundamental types. 107 typedef short __v4hi __attribute__ ((__vector_size__ (8))); 108 CHECK_VTABLE(__v4hi, fundamental); 109 110 // A does not have any bases. 111 CHECK_VTABLE(A, class); 112 113 // SI1 has a single public base. 114 CHECK_VTABLE(SI1, si_class); 115 CHECK(to<__si_class_type_info>(typeid(SI1)).__base_type == &typeid(A)); 116 117 // SI2 has a single public empty base. 118 CHECK_VTABLE(SI2, si_class); 119 CHECK(to<__si_class_type_info>(typeid(SI2)).__base_type == &typeid(Empty)); 120 121 // SI3 has a single public empty base. SI3 is dynamic whereas Empty is not, but since Empty is 122 // an empty class, it will still be at offset zero. 123 CHECK_VTABLE(SI3, si_class); 124 CHECK(to<__si_class_type_info>(typeid(SI3)).__base_type == &typeid(Empty)); 125 126 // VMI1 has a single base, but it is private. 127 CHECK_VTABLE(VMI1, vmi_class); 128 129 // VMI2 has a single base, but it is virtual. 130 CHECK_VTABLE(VMI2, vmi_class); 131 132 // VMI3 has a single base, but VMI3 is dynamic whereas A is not, and A is not empty. 133 CHECK_VTABLE(VMI3, vmi_class); 134 135 // VMI4 has two bases. 136 CHECK_VTABLE(VMI4, vmi_class); 137 138 // VMI5 has non-diamond shaped inheritance. 139 CHECK_VTABLE(VMI5, vmi_class); 140 CHECK(to<__vmi_class_type_info>(typeid(VMI5)).__flags == __vmi_class_type_info::__non_diamond_repeat_mask); 141 CHECK(to<__vmi_class_type_info>(typeid(VMI5)).__base_count == 2); 142 CHECK_BASE_INFO_TYPE(VMI5, 0, VMIBase1); 143 CHECK_BASE_INFO_OFFSET_FLAGS(VMI5, 0, 0, __base_class_type_info::__public_mask); 144 CHECK_BASE_INFO_TYPE(VMI5, 1, VMIBase2); 145 CHECK_BASE_INFO_OFFSET_FLAGS(VMI5, 1, 4, __base_class_type_info::__public_mask); 146 147 // VMI6 has diamond shaped inheritance. 148 CHECK_VTABLE(VMI6, vmi_class); 149 CHECK(to<__vmi_class_type_info>(typeid(VMI6)).__flags == __vmi_class_type_info::__diamond_shaped_mask); 150 CHECK(to<__vmi_class_type_info>(typeid(VMI6)).__base_count == 2); 151 CHECK_BASE_INFO_TYPE(VMI6, 0, VMIBase1); 152 CHECK_BASE_INFO_OFFSET_FLAGS(VMI6, 0, -24, __base_class_type_info::__public_mask | __base_class_type_info::__virtual_mask); 153 CHECK_BASE_INFO_TYPE(VMI6, 1, VMIBase3); 154 CHECK_BASE_INFO_OFFSET_FLAGS(VMI6, 1, 0, __base_class_type_info::__public_mask); 155 156 // VMI7 has both non-diamond and diamond shaped inheritance. 157 CHECK_VTABLE(VMI7, vmi_class); 158 CHECK(to<__vmi_class_type_info>(typeid(VMI7)).__flags == (__vmi_class_type_info::__non_diamond_repeat_mask | __vmi_class_type_info::__diamond_shaped_mask)); 159 CHECK(to<__vmi_class_type_info>(typeid(VMI7)).__base_count == 3); 160 CHECK_BASE_INFO_TYPE(VMI7, 0, VMIBase1); 161 CHECK_BASE_INFO_OFFSET_FLAGS(VMI7, 0, 16, __base_class_type_info::__public_mask); 162 CHECK_BASE_INFO_TYPE(VMI7, 1, VMI5); 163 CHECK_BASE_INFO_OFFSET_FLAGS(VMI7, 1, 20, __base_class_type_info::__public_mask); 164 CHECK_BASE_INFO_TYPE(VMI7, 2, VMI6); 165 CHECK_BASE_INFO_OFFSET_FLAGS(VMI7, 2, 0, 0); 166 167 // Pointers to incomplete classes. 168 CHECK_VTABLE(Incomplete *, pointer); 169 CHECK(to<__pbase_type_info>(typeid(Incomplete *)).__flags == __pbase_type_info::__incomplete_mask); 170 CHECK(to<__pbase_type_info>(typeid(Incomplete **)).__flags == __pbase_type_info::__incomplete_mask); 171 CHECK(to<__pbase_type_info>(typeid(Incomplete ***)).__flags == __pbase_type_info::__incomplete_mask); 172 173 // Member pointers. 174 CHECK_VTABLE(int Incomplete::*, pointer_to_member); 175 CHECK(to<__pbase_type_info>(typeid(int Incomplete::*)).__flags == __pbase_type_info::__incomplete_class_mask); 176 CHECK(to<__pbase_type_info>(typeid(Incomplete Incomplete::*)).__flags == (__pbase_type_info::__incomplete_class_mask | __pbase_type_info::__incomplete_mask)); 177 CHECK(to<__pbase_type_info>(typeid(Incomplete A::*)).__flags == (__pbase_type_info::__incomplete_mask)); 178 179 // Check that when stripping qualifiers off the pointee type, we correctly handle arrays. 180 CHECK(to<__pbase_type_info>(typeid(B::a)).__flags == (__pbase_type_info::__const_mask | __pbase_type_info::__volatile_mask)); 181 CHECK(to<__pbase_type_info>(typeid(B::a)).__pointee == to<__pbase_type_info>(typeid(B::b)).__pointee); 182 CHECK(to<__pbase_type_info>(typeid(B::c)).__flags == (__pbase_type_info::__const_mask | __pbase_type_info::__volatile_mask)); 183 CHECK(to<__pbase_type_info>(typeid(B::c)).__pointee == to<__pbase_type_info>(typeid(B::d)).__pointee); 184 185 // Success! 186 // CHECK: ret i32 0 187 return 0; 188 } 189 190 #ifdef HARNESS 191 extern "C" void printf(const char *, ...); 192 193 int main() { 194 int result = f(); 195 196 if (result == 0) 197 printf("success!\n"); 198 else 199 printf("test on line %d failed!\n", result); 200 201 return result; 202 } 203 #endif 204 205 206