clang/test/CodeGenObjCXX/encode.mm

   1 // RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++98 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX98,CHECK-NO-TEMP-SPEC %s
   2 // RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++20 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX20,CHECK-NO-TEMP-SPEC %s
   3 // RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++20 %s -triple=x86_64-apple-darwin10 -fobjc-encode-cxx-class-template-spec -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX20,CHECK-TEMP-SPEC %s
   4
   5 // CHECK: v17@0:8{vector<float, float, float>=}16
   6 // CHECK: {vector<float, float, float>=}
   7 // CHECK: v24@0:816
   8
   9 template <typename T1, typename T2, typename T3> struct vector {
  10   vector();
  11   vector(T1,T2,T3);
  12 };
  13
  14 typedef vector< float, float, float > vector3f;
  15
  16 @interface SceneNode
  17 {
  18  vector3f position;
  19 }
  20
  21 @property (assign, nonatomic) vector3f position;
  22
  23 @end
  24
  25 @interface MyOpenGLView
  26 {
  27 @public
  28   vector3f position;
  29 }
  30 @property vector3f position;
  31 @end
  32
  33 @implementation MyOpenGLView
  34
  35 @synthesize position;
  36
  37 -(void)awakeFromNib {
  38  SceneNode *sn;
  39  vector3f VF3(1.0, 1.0, 1.0);
  40  [sn setPosition:VF3];
  41 }
  42 @end
  43
  44
  45 class Int3 { int x, y, z; };
  46
  47 // Enforce @encoding for member pointers.
  48 @interface MemPtr {}
  49 - (void) foo: (int (Int3::*)) member;
  50 @end
  51 @implementation MemPtr
  52 - (void) foo: (int (Int3::*)) member {
  53 }
  54 @end
  55
  56 // rdar: // 8519948
  57 typedef float HGVec4f __attribute__ ((vector_size(16)));
  58
  59 @interface RedBalloonHGXFormWrapper {
  60   HGVec4f m_Transform[4];
  61 }
  62 @end
  63
  64 @implementation RedBalloonHGXFormWrapper
  65 @end
  66
  67 // rdar://9357400
  68 namespace rdar9357400 {
  69   template<int Dim1 = -1, int Dim2 = -1> struct fixed {
  70       template<int D> struct rebind { typedef fixed<D> other; };
  71   };
  72
  73   template<typename Element, int Size>
  74   class fixed_1D
  75   {
  76   public:
  77       typedef Element value_type;
  78       typedef value_type array_impl[Size];
  79     protected:
  80       array_impl                  m_data;
  81   };
  82
  83   template<typename Element, typename Alloc>
  84   class vector;
  85
  86   template<typename Element, int Size>
  87   class vector< Element, fixed<Size> >
  88   : public fixed_1D<Element,Size> { };
  89
  90   typedef vector< float,  fixed<4> > vector4f;
  91
  92   // FIXME: This difference is due to D76801. It was probably an unintentional change. Maybe we want to undo it?
  93   // @encoding for C++ is dependent on the TypePrinter implementation, which is a known issue. But since there
  94   // are currently no system frameworks that vend Objective-C++ types, a potential ABI break caused by changes
  95   // to the TypePrinter should not be a concern.
  96   // CHECKCXX98: @_ZN11rdar93574002ggE ={{.*}} constant [45 x i8] c"{vector<float, rdar9357400::fixed<4> >=[4f]}\00"
  97   // CHECKCXX20: @_ZN11rdar93574002ggE ={{.*}} constant [44 x i8] c"{vector<float, rdar9357400::fixed<4>>=[4f]}\00"
  98   extern const char gg[] = @encode(vector4f);
  99 }
 100
 101 // rdar://9624314
 102 namespace rdar9624314 {
 103   struct B2 { int x; };
 104   struct B3 {};
 105   struct S : B2, B3 {};
 106
 107   // CHECK: @_ZN11rdar96243142ggE ={{.*}} constant [6 x i8] c"{S=i}\00"
 108   extern const char gg[] = @encode(S);
 109
 110   struct S2 { unsigned : 0; int x; unsigned : 0; };
 111   // CHECK: @_ZN11rdar96243142g2E ={{.*}} constant [11 x i8] c"{S2=b0ib0}\00"
 112   extern const char g2[] = @encode(S2);
 113 }
 114
 115 namespace test {
 116   class Foo {
 117   public:
 118    virtual void f() {};
 119   };
 120
 121   class Bar {
 122   public:
 123    virtual void g() {};
 124   };
 125
 126   class Zoo : virtual public Foo, virtual public Bar {
 127   public:
 128    int x;
 129    int y;
 130   };
 131
 132   // CHECK: @_ZN4test3ecdE ={{.*}} constant [15 x i8] c"{Zoo=^^?ii^^?}\00"
 133   extern const char ecd[] = @encode(Zoo);
 134 }
 135
 136 struct Base1 {
 137   char x;
 138 };
 139
 140 struct DBase : public Base1 {
 141   double x;
 142   virtual ~DBase();
 143 };
 144
 145 struct Sub_with_virt : virtual DBase {
 146   long x;
 147 };
 148
 149 struct Sub2 : public Sub_with_virt, public Base1, virtual DBase {
 150   float x;
 151 };
 152
 153 // CHECK: @g1 ={{.*}} constant [10 x i8] c"{Base1=c}\00"
 154 extern const char g1[] = @encode(Base1);
 155
 156 // CHECK: @g2 ={{.*}} constant [14 x i8] c"{DBase=^^?cd}\00"
 157 extern const char g2[] = @encode(DBase);
 158
 159 // CHECK: @g3 ={{.*}} constant [26 x i8] c"{Sub_with_virt=^^?q^^?cd}\00"
 160 extern const char g3[] = @encode(Sub_with_virt);
 161
 162 // CHECK: @g4 ={{.*}} constant [19 x i8] c"{Sub2=^^?qcf^^?cd}\00"
 163 extern const char g4[] = @encode(Sub2);
 164
 165 // http://llvm.org/PR9927
 166 class allocator {
 167 };
 168 class basic_string     {
 169 struct _Alloc_hider : allocator       {
 170 char* _M_p;
 171 };
 172 _Alloc_hider _M_dataplus;
 173 };
 174
 175 // CHECK: @g5 ={{.*}} constant [32 x i8] c"{basic_string={_Alloc_hider=*}}\00"
 176 extern const char g5[] = @encode(basic_string);
 177
 178
 179 // PR10990
 180 struct CefBase {
 181   virtual ~CefBase() {}
 182 };
 183 struct CefBrowser : public virtual CefBase {};
 184 struct CefBrowserImpl : public CefBrowser {};
 185 // CHECK: @g6 ={{.*}} constant [21 x i8] c"{CefBrowserImpl=^^?}\00"
 186 extern const char g6[] = @encode(CefBrowserImpl);
 187
 188 // PR10990_2
 189 struct CefBase2 {
 190   virtual ~CefBase2() {}
 191   int i;
 192 };
 193 struct CefBrowser2 : public virtual CefBase2 {};
 194 struct CefBrowserImpl2 : public CefBrowser2 {};
 195 // CHECK: @g7 ={{.*}} constant [26 x i8] c"{CefBrowserImpl2=^^?^^?i}\00"
 196 extern const char g7[] = @encode(CefBrowserImpl2);
 197
 198 // <rdar://problem/11324167>
 199 struct Empty {};
 200
 201 struct X : Empty {
 202   int array[10];
 203 };
 204
 205 struct Y : Empty {
 206   X vec;
 207 };
 208
 209 // CHECK: @g8 ={{.*}} constant [14 x i8] c"{Y={X=[10i]}}\00"
 210 extern const char g8[] = @encode(Y);
 211
 212
 213 class dynamic_class {
 214 public:
 215   virtual ~dynamic_class();
 216 };
 217 @interface has_dynamic_class_ivar
 218 @end
 219 @implementation has_dynamic_class_ivar {
 220   dynamic_class dynamic_class_ivar;
 221 }
 222 @end
 223 // CHECK: private unnamed_addr constant [41 x i8] c"{dynamic_class=\22_vptr$dynamic_class\22^^?}\00"
 224
 225 namespace PR17142 {
 226   struct A { virtual ~A(); };
 227   struct B : virtual A { int y; };
 228   struct C { virtual ~C(); int z; };
 229   struct D : C, B { int a; };
 230   struct E : D {};
 231   // CHECK: @_ZN7PR171421xE ={{.*}} constant [14 x i8] c"{E=^^?i^^?ii}\00"
 232   extern const char x[] = @encode(E);
 233 }
 234
 235 // This test used to cause infinite recursion.
 236 template<typename T>
 237 struct S {
 238   typedef T Ty;
 239   Ty *t;
 240 };
 241
 242 @interface N
 243 {
 244   S<N> a;
 245 }
 246 @end
 247
 248 @implementation N
 249 @end
 250
 251 const char *expand_struct() {
 252   // CHECK: @{{.*}} = private unnamed_addr constant [13 x i8] c"{N={S<N>=@}}\00"
 253   return @encode(N);
 254 }
 255
 256 #if __cplusplus >= 202002L
 257 namespace PR48048 {
 258   struct F {};
 259   struct I {
 260     int m;
 261     [[no_unique_address]] F n;
 262   };
 263   // CHECKCXX20: @_ZN7PR480481xE ={{.*}} constant [6 x i8] c"{I=i}\00"
 264   extern const char x[] = @encode(I);
 265 }
 266 #endif
 267
 268 namespace test_cxx_template_specialization {
 269 template <class T>
 270 struct B0 {
 271   T a;
 272 };
 273 struct D0 : B0<int> {};
 274 struct D1 : D0 {};
 275 struct D2 : virtual B0<int> {};
 276 struct S0 {
 277   B0<int> a;
 278 };
 279 struct S1 {
 280   B0<int> *a;
 281 };
 282 struct S2 {
 283   S1 *a;
 284 };
 285 template <class T>
 286 union U0 {
 287   T a;
 288 };
 289 typedef B0<int> TD0;
 290 typedef B0<int> *Array0[4];
 291
 292 template <class T>
 293 struct Outer0 {
 294   struct Inner0 {
 295     int a;
 296   };
 297   template <class T1>
 298   struct Inner1 {
 299     T a;
 300     T1 b;
 301   };
 302 };
 303
 304 // CHECK: @[[STR22:.*]] = {{.*}} [12 x i8] c"{B0<int>=i}\00"
 305 // CHECK: @_ZN32test_cxx_template_specialization2b0E = global ptr @[[STR22]]
 306 // CHECK-NO-TEMP-SPEC: @[[STR23:.*]] = {{.*}} [3 x i8] c"^v\00"
 307 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization3b01E = global ptr @[[STR23]]
 308 // CHECK-TEMP-SPEC: @[[STR23:.*]] = {{.*}} [13 x i8] c"^{B0<int>=i}\00"
 309 // CHECK-TEMP-SPEC: @_ZN32test_cxx_template_specialization3b01E = global ptr @[[STR23]]
 310 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization3b02E = global ptr @[[STR23]]
 311 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2d0E = global ptr @[[STR23]]
 312 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2d1E = global ptr @[[STR23]]
 313 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2d2E = global ptr @[[STR23]]
 314 // CHECK: @[[STR24:.*]] = {{.*}} [7 x i8] c"^^{D2}\00"
 315 // CHECK: @_ZN32test_cxx_template_specialization3d21E = global ptr @[[STR24]]
 316 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2s0E = global ptr @[[STR23]]
 317 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2s1E = global ptr @[[STR23]]
 318 // CHECK: @[[STR25:.*]] = {{.*}} [12 x i8] c"^{S2=^{S1}}\00"
 319 // CHECK: @_ZN32test_cxx_template_specialization2s2E = global ptr @[[STR25]]
 320 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2u0E = global ptr @[[STR23]]
 321 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization3td0E = global ptr @[[STR23]]
 322 // CHECK-NO-TEMP-SPEC: @[[STR26:.*]] = {{.*}} [6 x i8] c"[4^v]\00"
 323 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2a0E = global ptr @[[STR26]]
 324 // CHECK: @[[STR27:.*]] = {{.*}} [11 x i8] c"^{Inner0=}\00"
 325 // CHECK: @_ZN32test_cxx_template_specialization6inner0E = global ptr @[[STR27]]
 326 // CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization6inner1E = global ptr @.str.23
 327 // CHECK-TEMP-SPEC: @[[STR34:.*]] = {{.*}} [18 x i8] c"^{Inner1<float>=}\00"
 328 // CHECK-TEMP-SPEC: @_ZN32test_cxx_template_specialization6inner1E = global ptr @[[STR34]]
 329
 330 const char *b0 = @encode(B0<int>);
 331 const char *b01 = @encode(B0<int> *);
 332 const char *b02 = @encode(B0<int> &);
 333 const char *d0 = @encode(D0 *);
 334 const char *d1 = @encode(D1 *);
 335 const char *d2 = @encode(D2 *);
 336 const char *d21 = @encode(D2 **);
 337 const char *s0 = @encode(S0 *);
 338 const char *s1 = @encode(S1 *);
 339 const char *s2 = @encode(S2 *);
 340 const char *u0 = @encode(U0<int> *);
 341 const char *td0 = @encode(TD0 *);
 342 const char *a0 = @encode(Array0);
 343 const char *inner0 = @encode(Outer0<int>::Inner0 *);
 344 const char *inner1 = @encode(Outer0<int>::Inner1<float> *);
 345 }