• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -triple %itanium_abi_triple -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s
2 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s
3 
4 // RUN: not %clang_cc1 -std=c++11 -fsyntax-only -triple %itanium_abi_triple -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s
5 // RUN: not %clang_cc1 -std=c++11 -fsyntax-only -triple %ms_abi_triple -fdiagnostics-parseable-fixits -Wreinterpret-base-class -Wno-unused-volatile-lvalue %s 2>&1 | FileCheck %s
6 
7 // PR 13824
8 class A {
9 };
10 class DA : public A {
11 };
12 class DDA : public DA {
13 };
14 class DAo : protected A {
15 };
16 class DAi : private A {
17 };
18 
19 class DVA : public virtual A {
20 };
21 class DDVA : public virtual DA {
22 };
23 class DMA : public virtual A, public virtual DA { //expected-warning{{direct base 'A' is inaccessible due to ambiguity:\n    class DMA -> class A\n    class DMA -> class DA -> class A}}
24 };
25 
26 class B;
27 
28 struct C {
29   // Do not fail on incompletely-defined classes.
30   decltype(reinterpret_cast<C *>(0)) foo;
31   decltype(reinterpret_cast<A *>((C *) 0)) bar;
32   decltype(reinterpret_cast<C *>((A *) 0)) baz;
33 };
34 
reinterpret_not_defined_class(B * b,C * c)35 void reinterpret_not_defined_class(B *b, C *c) {
36   // Should not fail if class has no definition.
37   (void)*reinterpret_cast<C *>(b);
38   (void)*reinterpret_cast<B *>(c);
39 
40   (void)reinterpret_cast<C &>(*b);
41   (void)reinterpret_cast<B &>(*c);
42 }
43 
44 // Do not fail on erroneous classes with fields of incompletely-defined types.
45 // Base class is malformed.
46 namespace BaseMalformed {
47   struct A; // expected-note {{forward declaration of 'BaseMalformed::A'}}
48   struct B {
49     A a; // expected-error {{field has incomplete type 'BaseMalformed::A'}}
50   };
51   struct C : public B {} c;
52   B *b = reinterpret_cast<B *>(&c);
53 } // end anonymous namespace
54 
55 // Child class is malformed.
56 namespace ChildMalformed {
57   struct A; // expected-note {{forward declaration of 'ChildMalformed::A'}}
58   struct B {};
59   struct C : public B {
60     A a; // expected-error {{field has incomplete type 'ChildMalformed::A'}}
61   } c;
62   B *b = reinterpret_cast<B *>(&c);
63 } // end anonymous namespace
64 
65 // Base class outside upcast base-chain is malformed.
66 namespace BaseBaseMalformed {
67   struct A; // expected-note {{forward declaration of 'BaseBaseMalformed::A'}}
68   struct Y {};
69   struct X { A a; }; // expected-error {{field has incomplete type 'BaseBaseMalformed::A'}}
70   struct B : Y, X {};
71   struct C : B {} c;
72   B *p = reinterpret_cast<B*>(&c);
73 }
74 
75 namespace InheritanceMalformed {
76   struct A; // expected-note {{forward declaration of 'InheritanceMalformed::A'}}
77   struct B : A {}; // expected-error {{base class has incomplete type}}
78   struct C : B {} c;
79   B *p = reinterpret_cast<B*>(&c);
80 }
81 
82 // Virtual base class outside upcast base-chain is malformed.
83 namespace VBaseMalformed{
84   struct A; // expected-note {{forward declaration of 'VBaseMalformed::A'}}
85   struct X { A a; };  // expected-error {{field has incomplete type 'VBaseMalformed::A'}}
86   struct B : public virtual X {};
87   struct C : B {} c;
88   B *p = reinterpret_cast<B*>(&c);
89 }
90 
reinterpret_not_updowncast(A * pa,const A * pca,A & a,const A & ca)91 void reinterpret_not_updowncast(A *pa, const A *pca, A &a, const A &ca) {
92   (void)*reinterpret_cast<C *>(pa);
93   (void)*reinterpret_cast<const C *>(pa);
94   (void)*reinterpret_cast<volatile C *>(pa);
95   (void)*reinterpret_cast<const volatile C *>(pa);
96 
97   (void)*reinterpret_cast<const C *>(pca);
98   (void)*reinterpret_cast<const volatile C *>(pca);
99 
100   (void)reinterpret_cast<C &>(a);
101   (void)reinterpret_cast<const C &>(a);
102   (void)reinterpret_cast<volatile C &>(a);
103   (void)reinterpret_cast<const volatile C &>(a);
104 
105   (void)reinterpret_cast<const C &>(ca);
106   (void)reinterpret_cast<const volatile C &>(ca);
107 }
108 
reinterpret_pointer_downcast(A * a,const A * ca)109 void reinterpret_pointer_downcast(A *a, const A *ca) {
110   (void)*reinterpret_cast<DA *>(a);
111   (void)*reinterpret_cast<const DA *>(a);
112   (void)*reinterpret_cast<volatile DA *>(a);
113   (void)*reinterpret_cast<const volatile DA *>(a);
114 
115   (void)*reinterpret_cast<const DA *>(ca);
116   (void)*reinterpret_cast<const volatile DA *>(ca);
117 
118   (void)*reinterpret_cast<DDA *>(a);
119   (void)*reinterpret_cast<DAo *>(a);
120   (void)*reinterpret_cast<DAi *>(a);
121   // expected-warning@+2 {{'reinterpret_cast' to class 'DVA *' from its virtual base 'A *' behaves differently from 'static_cast'}}
122   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
123   (void)*reinterpret_cast<DVA *>(a);
124   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
125 
126   // expected-warning@+2 {{'reinterpret_cast' to class 'DDVA *' from its virtual base 'A *' behaves differently from 'static_cast'}}
127   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
128   (void)*reinterpret_cast<DDVA *>(a);
129   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
130 
131   // expected-warning@+2 {{'reinterpret_cast' to class 'DMA *' from its virtual base 'A *' behaves differently from 'static_cast'}}
132   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
133   (void)*reinterpret_cast<DMA *>(a);
134   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
135 }
136 
reinterpret_reference_downcast(A a,A & ra,const A & cra)137 void reinterpret_reference_downcast(A a, A &ra, const A &cra) {
138   (void)reinterpret_cast<DA &>(a);
139   (void)reinterpret_cast<const DA &>(a);
140   (void)reinterpret_cast<volatile DA &>(a);
141   (void)reinterpret_cast<const volatile DA &>(a);
142 
143   (void)reinterpret_cast<DA &>(ra);
144   (void)reinterpret_cast<const DA &>(ra);
145   (void)reinterpret_cast<volatile DA &>(ra);
146   (void)reinterpret_cast<const volatile DA &>(ra);
147 
148   (void)reinterpret_cast<const DA &>(cra);
149   (void)reinterpret_cast<const volatile DA &>(cra);
150 
151   (void)reinterpret_cast<DDA &>(a);
152   (void)reinterpret_cast<DAo &>(a);
153   (void)reinterpret_cast<DAi &>(a);
154   // expected-warning@+2 {{'reinterpret_cast' to class 'DVA &' from its virtual base 'A' behaves differently from 'static_cast'}}
155   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
156   (void)reinterpret_cast<DVA &>(a);
157   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
158 
159   // expected-warning@+2 {{'reinterpret_cast' to class 'DDVA &' from its virtual base 'A' behaves differently from 'static_cast'}}
160   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
161   (void)reinterpret_cast<DDVA &>(a);
162   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
163 
164   // expected-warning@+2 {{'reinterpret_cast' to class 'DMA &' from its virtual base 'A' behaves differently from 'static_cast'}}
165   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
166   (void)reinterpret_cast<DMA &>(a);
167   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
168 }
169 
reinterpret_pointer_upcast(DA * da,const DA * cda,DDA * dda,DAo * dao,DAi * dai,DVA * dva,DDVA * ddva,DMA * dma)170 void reinterpret_pointer_upcast(DA *da, const DA *cda, DDA *dda, DAo *dao,
171                                 DAi *dai, DVA *dva, DDVA *ddva, DMA *dma) {
172   (void)*reinterpret_cast<A *>(da);
173   (void)*reinterpret_cast<const A *>(da);
174   (void)*reinterpret_cast<volatile A *>(da);
175   (void)*reinterpret_cast<const volatile A *>(da);
176 
177   (void)*reinterpret_cast<const A *>(cda);
178   (void)*reinterpret_cast<const volatile A *>(cda);
179 
180   (void)*reinterpret_cast<A *>(dda);
181   (void)*reinterpret_cast<DA *>(dda);
182   (void)*reinterpret_cast<A *>(dao);
183   (void)*reinterpret_cast<A *>(dai);
184   // expected-warning@+2 {{'reinterpret_cast' from class 'DVA *' to its virtual base 'A *' behaves differently from 'static_cast'}}
185   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
186   (void)*reinterpret_cast<A *>(dva);
187   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
188 
189   // expected-warning@+2 {{'reinterpret_cast' from class 'DDVA *' to its virtual base 'A *' behaves differently from 'static_cast'}}
190   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
191   (void)*reinterpret_cast<A *>(ddva);
192   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
193 
194   // expected-warning@+2 {{'reinterpret_cast' from class 'DDVA *' to its virtual base 'DA *' behaves differently from 'static_cast'}}
195   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
196   (void)*reinterpret_cast<DA *>(ddva);
197   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
198 
199   // expected-warning@+2 {{'reinterpret_cast' from class 'DMA *' to its virtual base 'A *' behaves differently from 'static_cast'}}
200   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
201   (void)*reinterpret_cast<A *>(dma);
202   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
203 
204   // expected-warning@+2 {{'reinterpret_cast' from class 'DMA *' to its virtual base 'DA *' behaves differently from 'static_cast'}}
205   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
206   (void)*reinterpret_cast<DA *>(dma);
207   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:10-[[@LINE-1]]:26}:"static_cast"
208 }
209 
reinterpret_reference_upcast(DA & da,const DA & cda,DDA & dda,DAo & dao,DAi & dai,DVA & dva,DDVA & ddva,DMA & dma)210 void reinterpret_reference_upcast(DA &da, const DA &cda, DDA &dda, DAo &dao,
211                                   DAi &dai, DVA &dva, DDVA &ddva, DMA &dma) {
212   (void)reinterpret_cast<A &>(da);
213   (void)reinterpret_cast<const A &>(da);
214   (void)reinterpret_cast<volatile A &>(da);
215   (void)reinterpret_cast<const volatile A &>(da);
216 
217   (void)reinterpret_cast<const A &>(cda);
218   (void)reinterpret_cast<const volatile A &>(cda);
219 
220   (void)reinterpret_cast<A &>(dda);
221   (void)reinterpret_cast<DA &>(dda);
222   (void)reinterpret_cast<A &>(dao);
223   (void)reinterpret_cast<A &>(dai);
224   // expected-warning@+2 {{'reinterpret_cast' from class 'DVA' to its virtual base 'A &' behaves differently from 'static_cast'}}
225   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
226   (void)reinterpret_cast<A &>(dva);
227   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
228 
229   // expected-warning@+2 {{'reinterpret_cast' from class 'DDVA' to its virtual base 'A &' behaves differently from 'static_cast'}}
230   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
231   (void)reinterpret_cast<A &>(ddva);
232   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
233 
234   // expected-warning@+2 {{'reinterpret_cast' from class 'DDVA' to its virtual base 'DA &' behaves differently from 'static_cast'}}
235   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
236   (void)reinterpret_cast<DA &>(ddva);
237   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
238 
239   // expected-warning@+2 {{'reinterpret_cast' from class 'DMA' to its virtual base 'A &' behaves differently from 'static_cast'}}
240   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
241   (void)reinterpret_cast<A &>(dma);
242   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
243 
244   // expected-warning@+2 {{'reinterpret_cast' from class 'DMA' to its virtual base 'DA &' behaves differently from 'static_cast'}}
245   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
246   (void)reinterpret_cast<DA &>(dma);
247   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
248 }
249 
250 struct E {
251   int x;
252 };
253 
254 class F : public E {
foo()255   virtual int foo() { return x; }
256 };
257 
258 class G : public F {
259 };
260 
261 class H : public E, public A {
262 };
263 
264 class I : virtual public F {
265 };
266 
267 typedef const F * K;
268 typedef volatile K L;
269 
different_subobject_downcast(E * e,F * f,A * a)270 void different_subobject_downcast(E *e, F *f, A *a) {
271   // expected-warning@+2 {{'reinterpret_cast' to class 'F *' from its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
272   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
273   (void)reinterpret_cast<F *>(e);
274   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
275 
276   // expected-warning@+2 {{'reinterpret_cast' to class 'G *' from its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
277   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
278   (void)reinterpret_cast<G *>(e);
279   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
280 
281   (void)reinterpret_cast<H *>(e);
282   // expected-warning@+2 {{'reinterpret_cast' to class 'I *' from its virtual base 'E *' behaves differently from 'static_cast'}}
283   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
284   (void)reinterpret_cast<I *>(e);
285   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
286 
287 
288   (void)reinterpret_cast<G *>(f);
289   // expected-warning@+2 {{'reinterpret_cast' to class 'I *' from its virtual base 'F *' behaves differently from 'static_cast'}}
290   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
291   (void)reinterpret_cast<I *>(f);
292   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
293 
294 #ifdef MSABI
295   // In MS ABI mode, A is at non-zero offset in H.
296   // expected-warning@+3 {{'reinterpret_cast' to class 'H *' from its base at non-zero offset 'A *' behaves differently from 'static_cast'}}
297   // expected-note@+2 {{use 'static_cast'}}
298 #endif
299   (void)reinterpret_cast<H *>(a);
300 
301   // expected-warning@+2 {{'reinterpret_cast' to class 'L' (aka 'const F *volatile') from its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
302   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while downcasting}}
303   (void)reinterpret_cast<L>(e);
304   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
305 }
306 
different_subobject_upcast(F * f,G * g,H * h,I * i)307 void different_subobject_upcast(F *f, G *g, H *h, I *i) {
308   // expected-warning@+2 {{'reinterpret_cast' from class 'F *' to its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
309   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
310   (void)reinterpret_cast<E *>(f);
311   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
312 
313   (void)reinterpret_cast<F *>(g);
314   // expected-warning@+2 {{'reinterpret_cast' from class 'G *' to its base at non-zero offset 'E *' behaves differently from 'static_cast'}}
315   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
316   (void)reinterpret_cast<E *>(g);
317   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
318 
319   (void)reinterpret_cast<E *>(h);
320 
321 #ifdef MSABI
322   // In MS ABI mode, A is at non-zero offset in H.
323   // expected-warning@+3 {{'reinterpret_cast' from class 'H *' to its base at non-zero offset 'A *' behaves differently from 'static_cast'}}
324   // expected-note@+2 {{use 'static_cast'}}
325 #endif
326   (void)reinterpret_cast<A *>(h);
327 
328   // expected-warning@+2 {{'reinterpret_cast' from class 'I *' to its virtual base 'F *' behaves differently from 'static_cast'}}
329   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
330   (void)reinterpret_cast<F *>(i);
331   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
332 
333   // expected-warning@+2 {{'reinterpret_cast' from class 'I *' to its virtual base 'E *' behaves differently from 'static_cast'}}
334   // expected-note@+1 {{use 'static_cast' to adjust the pointer correctly while upcasting}}
335   (void)reinterpret_cast<E *>(i);
336   // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:9-[[@LINE-1]]:25}:"static_cast"
337 }
338