1 // RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-unreachable-code
2 // RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=gnu++11 %s -Wno-unreachable-code
3 
4 namespace test0 {
5   struct D { ~D(); };
6 
7   int f(bool b) {
8     if (b) {
9       D d;
10       goto end;
11     }
12 
13   end:
14     return 1;
15   }
16 }
17 
18 namespace test1 {
19   struct C { C(); };
20 
21   int f(bool b) {
22     if (b)
23       goto foo; // expected-error {{illegal goto into protected scope}}
24     C c; // expected-note {{jump bypasses variable initialization}}
25   foo:
26     return 1;
27   }
28 }
29 
30 namespace test2 {
31   struct C { C(); };
32 
33   int f(void **ip) {
34     static void *ips[] = { &&lbl1, &&lbl2 };
35 
36     C c;
37     goto *ip;
38   lbl1:
39     return 0;
40   lbl2:
41     return 1;
42   }
43 }
44 
45 namespace test3 {
46   struct C { C(); };
47 
48   int f(void **ip) {
49     static void *ips[] = { &&lbl1, &&lbl2 };
50 
51     goto *ip;
52   lbl1: {
53     C c;
54     return 0;
55   }
56   lbl2:
57     return 1;
58   }
59 }
60 
61 namespace test4 {
62   struct C { C(); };
63   struct D { ~D(); };
64 
65   int f(void **ip) {
66     static void *ips[] = { &&lbl1, &&lbl2 };
67 
68     C c0;
69 
70     goto *ip; // expected-error {{indirect goto might cross protected scopes}}
71     C c1; // expected-note {{jump bypasses variable initialization}}
72   lbl1: // expected-note {{possible target of indirect goto}}
73     return 0;
74   lbl2:
75     return 1;
76   }
77 }
78 
79 namespace test5 {
80   struct C { C(); };
81   struct D { ~D(); };
82 
83   int f(void **ip) {
84     static void *ips[] = { &&lbl1, &&lbl2 };
85     C c0;
86 
87     goto *ip;
88   lbl1: // expected-note {{possible target of indirect goto}}
89     return 0;
90   lbl2:
91     if (ip[1]) {
92       D d; // expected-note {{jump exits scope of variable with non-trivial destructor}}
93       ip += 2;
94       goto *ip; // expected-error {{indirect goto might cross protected scopes}}
95     }
96     return 1;
97   }
98 }
99 
100 namespace test6 {
101   struct C { C(); };
102 
103   unsigned f(unsigned s0, unsigned s1, void **ip) {
104     static void *ips[] = { &&lbl1, &&lbl2, &&lbl3, &&lbl4 };
105     C c0;
106 
107     goto *ip;
108   lbl1:
109     s0++;
110     goto *++ip;
111   lbl2:
112     s0 -= s1;
113     goto *++ip;
114   lbl3: {
115     unsigned tmp = s0;
116     s0 = s1;
117     s1 = tmp;
118     goto *++ip;
119   }
120   lbl4:
121     return s0;
122   }
123 }
124 
125 // C++0x says it's okay to skip non-trivial initializers on static
126 // locals, and we implement that in '03 as well.
127 namespace test7 {
128   struct C { C(); };
129 
130   void test() {
131     goto foo;
132     static C c;
133   foo:
134     return;
135   }
136 }
137 
138 // PR7789
139 namespace test8 {
140   void test1(int c) {
141     switch (c) {
142     case 0:
143       int x = 56; // expected-note {{jump bypasses variable initialization}}
144     case 1:       // expected-error {{switch case is in protected scope}}
145       x = 10;
146     }
147   }
148 
149   void test2() {
150     goto l2;     // expected-error {{goto into protected scope}}
151   l1: int x = 5; // expected-note {{jump bypasses variable initialization}}
152   l2: x++;
153   }
154 }
155 
156 namespace test9 {
157   struct S { int i; };
158   void test1() {
159     goto foo;
160     S s;
161   foo:
162     return;
163   }
164   unsigned test2(unsigned x, unsigned y) {
165     switch (x) {
166     case 2:
167       S s;
168       if (y > 42) return x + y;
169     default:
170       return x - 2;
171     }
172   }
173 }
174 
175 // http://llvm.org/PR10462
176 namespace PR10462 {
177 enum MyEnum {
178   something_valid,
179   something_invalid
180 };
181 
182 bool recurse() {
183   MyEnum K;
184   switch (K) { // expected-warning {{enumeration value 'something_invalid' not handled in switch}}
185     case something_valid:
186     case what_am_i_thinking: // expected-error {{use of undeclared identifier}}
187       int *X = 0;
188       if (recurse()) {
189       }
190 
191       break;
192   }
193 }
194 
195 
196 namespace test10 {
197 
198 int test() {
199   static void *ps[] = { &&a0 };
200   goto *&&a0; // expected-error {{goto into protected scope}}
201   int a = 3; // expected-note {{jump bypasses variable initialization}}
202  a0:
203   return 0;
204 }
205 
206 }
207 
208 }
209 
210