Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions %s -Wno-unreachable-code
      2 // RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions -std=gnu++11 %s -Wno-unreachable-code
      3 
      4 namespace testInvalid {
      5 Invalid inv; // expected-error {{unknown type name}}
      6 // Make sure this doesn't assert.
      7 void fn()
      8 {
      9     int c = 0;
     10     if (inv)
     11 Here: ;
     12     goto Here;
     13 }
     14 }
     15 
     16 namespace test0 {
     17   struct D { ~D(); };
     18 
     19   int f(bool b) {
     20     if (b) {
     21       D d;
     22       goto end;
     23     }
     24 
     25   end:
     26     return 1;
     27   }
     28 }
     29 
     30 namespace test1 {
     31   struct C { C(); };
     32 
     33   int f(bool b) {
     34     if (b)
     35       goto foo; // expected-error {{cannot jump}}
     36     C c; // expected-note {{jump bypasses variable initialization}}
     37   foo:
     38     return 1;
     39   }
     40 }
     41 
     42 namespace test2 {
     43   struct C { C(); };
     44 
     45   int f(void **ip) {
     46     static void *ips[] = { &&lbl1, &&lbl2 };
     47 
     48     C c;
     49     goto *ip;
     50   lbl1:
     51     return 0;
     52   lbl2:
     53     return 1;
     54   }
     55 }
     56 
     57 namespace test3 {
     58   struct C { C(); };
     59 
     60   int f(void **ip) {
     61     static void *ips[] = { &&lbl1, &&lbl2 };
     62 
     63     goto *ip;
     64   lbl1: {
     65     C c;
     66     return 0;
     67   }
     68   lbl2:
     69     return 1;
     70   }
     71 }
     72 
     73 namespace test4 {
     74   struct C { C(); };
     75   struct D { ~D(); };
     76 
     77   int f(void **ip) {
     78     static void *ips[] = { &&lbl1, &&lbl2 };
     79 
     80     C c0;
     81 
     82     goto *ip; // expected-error {{cannot jump}}
     83     C c1; // expected-note {{jump bypasses variable initialization}}
     84   lbl1: // expected-note {{possible target of indirect goto}}
     85     return 0;
     86   lbl2:
     87     return 1;
     88   }
     89 }
     90 
     91 namespace test5 {
     92   struct C { C(); };
     93   struct D { ~D(); };
     94 
     95   int f(void **ip) {
     96     static void *ips[] = { &&lbl1, &&lbl2 };
     97     C c0;
     98 
     99     goto *ip;
    100   lbl1: // expected-note {{possible target of indirect goto}}
    101     return 0;
    102   lbl2:
    103     if (ip[1]) {
    104       D d; // expected-note {{jump exits scope of variable with non-trivial destructor}}
    105       ip += 2;
    106       goto *ip; // expected-error {{cannot jump}}
    107     }
    108     return 1;
    109   }
    110 }
    111 
    112 namespace test6 {
    113   struct C { C(); };
    114 
    115   unsigned f(unsigned s0, unsigned s1, void **ip) {
    116     static void *ips[] = { &&lbl1, &&lbl2, &&lbl3, &&lbl4 };
    117     C c0;
    118 
    119     goto *ip;
    120   lbl1:
    121     s0++;
    122     goto *++ip;
    123   lbl2:
    124     s0 -= s1;
    125     goto *++ip;
    126   lbl3: {
    127     unsigned tmp = s0;
    128     s0 = s1;
    129     s1 = tmp;
    130     goto *++ip;
    131   }
    132   lbl4:
    133     return s0;
    134   }
    135 }
    136 
    137 // C++0x says it's okay to skip non-trivial initializers on static
    138 // locals, and we implement that in '03 as well.
    139 namespace test7 {
    140   struct C { C(); };
    141 
    142   void test() {
    143     goto foo;
    144     static C c;
    145   foo:
    146     return;
    147   }
    148 }
    149 
    150 // PR7789
    151 namespace test8 {
    152   void test1(int c) {
    153     switch (c) {
    154     case 0:
    155       int x = 56; // expected-note {{jump bypasses variable initialization}}
    156     case 1:       // expected-error {{cannot jump}}
    157       x = 10;
    158     }
    159   }
    160 
    161   void test2() {
    162     goto l2;     // expected-error {{cannot jump}}
    163   l1: int x = 5; // expected-note {{jump bypasses variable initialization}}
    164   l2: x++;
    165   }
    166 }
    167 
    168 namespace test9 {
    169   struct S { int i; };
    170   void test1() {
    171     goto foo;
    172     S s;
    173   foo:
    174     return;
    175   }
    176   unsigned test2(unsigned x, unsigned y) {
    177     switch (x) {
    178     case 2:
    179       S s;
    180       if (y > 42) return x + y;
    181     default:
    182       return x - 2;
    183     }
    184   }
    185 }
    186 
    187 // http://llvm.org/PR10462
    188 namespace PR10462 {
    189   enum MyEnum {
    190     something_valid,
    191     something_invalid
    192   };
    193 
    194   bool recurse() {
    195     MyEnum K;
    196     switch (K) { // expected-warning {{enumeration value 'something_invalid' not handled in switch}}
    197     case something_valid:
    198     case what_am_i_thinking: // expected-error {{use of undeclared identifier}}
    199       int *X = 0;
    200       if (recurse()) {
    201       }
    202 
    203       break;
    204     }
    205   }
    206 }
    207 
    208 namespace test10 {
    209   int test() {
    210     static void *ps[] = { &&a0 };
    211     goto *&&a0; // expected-error {{cannot jump}}
    212     int a = 3; // expected-note {{jump bypasses variable initialization}}
    213   a0:
    214     return 0;
    215   }
    216 }
    217 
    218 // pr13812
    219 namespace test11 {
    220   struct C {
    221     C(int x);
    222     ~C();
    223   };
    224   void f(void **ip) {
    225     static void *ips[] = { &&l0 };
    226   l0:  // expected-note {{possible target of indirect goto}}
    227     C c0 = 42; // expected-note {{jump exits scope of variable with non-trivial destructor}}
    228     goto *ip; // expected-error {{cannot jump}}
    229   }
    230 }
    231 
    232 namespace test12 {
    233   struct C {
    234     C(int x);
    235     ~C();
    236   };
    237   void f(void **ip) {
    238     static void *ips[] = { &&l0 };
    239     const C c0 = 17;
    240   l0: // expected-note {{possible target of indirect goto}}
    241     const C &c1 = 42; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
    242     const C &c2 = c0;
    243     goto *ip; // expected-error {{cannot jump}}
    244   }
    245 }
    246 
    247 namespace test13 {
    248   struct C {
    249     C(int x);
    250     ~C();
    251     int i;
    252   };
    253   void f(void **ip) {
    254     static void *ips[] = { &&l0 };
    255   l0: // expected-note {{possible target of indirect goto}}
    256     const int &c1 = C(1).i; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
    257     goto *ip;  // expected-error {{cannot jump}}
    258   }
    259 }
    260 
    261 namespace test14 {
    262   struct C {
    263     C(int x);
    264     ~C();
    265     operator int&() const;
    266   };
    267   void f(void **ip) {
    268     static void *ips[] = { &&l0 };
    269   l0:
    270     // no warning since the C temporary is destructed before the goto.
    271     const int &c1 = C(1);
    272     goto *ip;
    273   }
    274 }
    275 
    276 // PR14225
    277 namespace test15 {
    278   void f1() try {
    279     goto x; // expected-error {{cannot jump}}
    280   } catch(...) {  // expected-note {{jump bypasses initialization of catch block}}
    281     x: ;
    282   }
    283   void f2() try {  // expected-note {{jump bypasses initialization of try block}}
    284     x: ;
    285   } catch(...) {
    286     goto x; // expected-error {{cannot jump}}
    287   }
    288 }
    289 
    290 namespace test16 {
    291   struct S { int n; };
    292   int f() {
    293     goto x; // expected-error {{cannot jump}}
    294     const S &s = S(); // expected-note {{jump bypasses variable initialization}}
    295 x:  return s.n;
    296   }
    297 }
    298 
    299 #if __cplusplus >= 201103L
    300 namespace test17 {
    301   struct S { int get(); private: int n; };
    302   int f() {
    303     goto x; // expected-error {{cannot jump}}
    304     S s = {}; // expected-note {{jump bypasses variable initialization}}
    305 x:  return s.get();
    306   }
    307 }
    308 #endif
    309 
    310 namespace test18 {
    311   struct A { ~A(); };
    312   struct B { const int &r; const A &a; };
    313   int f() {
    314     void *p = &&x;
    315     const A a = A();
    316   x:
    317     B b = { 0, a }; // ok
    318     goto *p;
    319   }
    320   int g() {
    321     void *p = &&x;
    322   x: // expected-note {{possible target of indirect goto}}
    323     B b = { 0, A() }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
    324     goto *p; // expected-error {{cannot jump}}
    325   }
    326 }
    327 
    328 #if __cplusplus >= 201103L
    329 namespace std {
    330   typedef decltype(sizeof(int)) size_t;
    331   template<typename T> struct initializer_list {
    332     const T *begin;
    333     size_t size;
    334     initializer_list(const T *, size_t);
    335   };
    336 }
    337 namespace test19 {
    338   struct A { ~A(); };
    339 
    340   int f() {
    341     void *p = &&x;
    342     A a;
    343   x: // expected-note {{possible target of indirect goto}}
    344     std::initializer_list<A> il = { a }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
    345     goto *p; // expected-error {{cannot jump}}
    346   }
    347 }
    348 
    349 namespace test20 {
    350   struct A { ~A(); };
    351   struct B {
    352     const A &a;
    353   };
    354 
    355   int f() {
    356     void *p = &&x;
    357     A a;
    358   x:
    359     std::initializer_list<B> il = {
    360       a,
    361       a
    362     };
    363     goto *p;
    364   }
    365   int g() {
    366     void *p = &&x;
    367     A a;
    368   x: // expected-note {{possible target of indirect goto}}
    369     std::initializer_list<B> il = {
    370       a,
    371       { A() } // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
    372     };
    373     goto *p; // expected-error {{cannot jump}}
    374   }
    375 }
    376 #endif
    377 
    378 namespace test21 {
    379   template<typename T> void f() {
    380   goto x; // expected-error {{cannot jump}}
    381     T t; // expected-note {{bypasses}}
    382  x: return;
    383   }
    384 
    385   template void f<int>();
    386   struct X { ~X(); };
    387   template void f<X>(); // expected-note {{instantiation of}}
    388 }
    389 
    390 namespace PR18217 {
    391   typedef int *X;
    392 
    393   template <typename T>
    394   class MyCl {
    395     T mem;
    396   };
    397 
    398   class Source {
    399     MyCl<X> m;
    400   public:
    401     int getKind() const;
    402   };
    403 
    404   bool b;
    405   template<typename TT>
    406   static void foo(const Source &SF, MyCl<TT *> Source::*m) {
    407     switch (SF.getKind()) {
    408       case 1: return;
    409       case 2: break;
    410       case 3:
    411       case 4: return;
    412     };
    413     if (b) {
    414       auto &y = const_cast<MyCl<TT *> &>(SF.*m); // expected-warning 0-1{{extension}}
    415     }
    416   }
    417 
    418   int Source::getKind() const {
    419     foo(*this, &Source::m);
    420     return 0;
    421   }
    422 }
    423 
    424 namespace test_recovery {
    425   // Test that jump scope checking recovers when there are unspecified errors
    426   // in the function declaration or body.
    427 
    428   void test(nexist, int c) { // expected-error {{}}
    429     nexist_fn(); // expected-error {{}}
    430     goto nexist_label; // expected-error {{use of undeclared label}}
    431     goto a0; // expected-error {{cannot jump}}
    432     int a = 0; // expected-note {{jump bypasses variable initialization}}
    433     a0:;
    434 
    435     switch (c) {
    436     case $: // expected-error {{}}
    437     case 0:
    438       int x = 56; // expected-note {{jump bypasses variable initialization}}
    439     case 1: // expected-error {{cannot jump}}
    440       x = 10;
    441     }
    442   }
    443 }
    444 
    445 namespace seh {
    446 
    447 // Jumping into SEH try blocks is not permitted.
    448 
    449 void jump_into_except() {
    450   goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}
    451   __try { // expected-note {{jump bypasses initialization of __try block}}
    452   into_try_except_try:
    453     ;
    454   } __except(0) {
    455   }
    456 
    457   goto into_try_except_except; // expected-error {{cannot jump from this goto statement to its label}}
    458   __try {
    459   } __except(0) { // expected-note {{jump bypasses initialization of __except block}}
    460   into_try_except_except:
    461     ;
    462   }
    463 }
    464 
    465 void jump_into_finally() {
    466   goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}
    467   __try { // expected-note {{jump bypasses initialization of __try block}}
    468   into_try_except_try:
    469     ;
    470   } __finally {
    471   }
    472 
    473   goto into_try_except_finally; // expected-error {{cannot jump from this goto statement to its label}}
    474   __try {
    475   } __finally { // expected-note {{jump bypasses initialization of __finally block}}
    476   into_try_except_finally:
    477     ;
    478   }
    479 }
    480 
    481 // Jumping out of SEH try blocks ok in general. (Jumping out of a __finally
    482 // has undefined behavior.)
    483 
    484 void jump_out_of_except() {
    485   __try {
    486     goto out_of_except_try;
    487   } __except(0) {
    488   }
    489 out_of_except_try:
    490   ;
    491 
    492   __try {
    493   } __except(0) {
    494     goto out_of_except_except;
    495   }
    496 out_of_except_except:
    497   ;
    498 }
    499 
    500 void jump_out_of_finally() {
    501   __try {
    502   goto out_of_finally_try;
    503   } __finally {
    504   }
    505 out_of_finally_try:
    506   ;
    507 
    508   __try {
    509   } __finally {
    510     goto out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}
    511   }
    512 
    513   __try {
    514   } __finally {
    515     goto *&&out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}
    516   }
    517 out_of_finally_finally:
    518   ;
    519 }
    520 
    521 // Jumping between protected scope and handler is not permitted.
    522 
    523 void jump_try_except() {
    524   __try {
    525     goto from_try_to_except; // expected-error {{cannot jump from this goto statement to its label}}
    526   } __except(0) { // expected-note {{jump bypasses initialization of __except block}}
    527   from_try_to_except:
    528     ;
    529   }
    530 
    531   __try { // expected-note {{jump bypasses initialization of __try block}}
    532   from_except_to_try:
    533     ;
    534   } __except(0) {
    535     goto from_except_to_try; // expected-error {{cannot jump from this goto statement to its label}}
    536   }
    537 }
    538 
    539 void jump_try_finally() {
    540   __try {
    541     goto from_try_to_finally; // expected-error {{cannot jump from this goto statement to its label}}
    542   } __finally { // expected-note {{jump bypasses initialization of __finally block}}
    543   from_try_to_finally:
    544     ;
    545   }
    546 
    547   __try { // expected-note {{jump bypasses initialization of __try block}}
    548   from_finally_to_try:
    549     ;
    550   } __finally {
    551     goto from_finally_to_try; // expected-error {{cannot jump from this goto statement to its label}} expected-warning {{jump out of __finally block has undefined behavior}}
    552   }
    553 }
    554 
    555 void nested() {
    556   // These are not permitted.
    557   __try {
    558     __try {
    559     } __finally {
    560       goto outer_except; // expected-error {{cannot jump from this goto statement to its label}}
    561     }
    562   } __except(0) { // expected-note {{jump bypasses initialization of __except bloc}}
    563   outer_except:
    564     ;
    565   }
    566 
    567   __try {
    568     __try{
    569     } __except(0) {
    570       goto outer_finally; // expected-error {{cannot jump from this goto statement to its label}}
    571     }
    572   } __finally { // expected-note {{jump bypasses initialization of __finally bloc}}
    573   outer_finally:
    574     ;
    575   }
    576 
    577   // These are permitted.
    578   __try {
    579     __try {
    580     } __finally {
    581       goto after_outer_except; // expected-warning {{jump out of __finally block has undefined behavior}}
    582     }
    583   } __except(0) {
    584   }
    585 after_outer_except:
    586   ;
    587 
    588   __try {
    589     __try{
    590     } __except(0) {
    591       goto after_outer_finally;
    592     }
    593   } __finally {
    594   }
    595 after_outer_finally:
    596   ;
    597 }
    598 
    599 // This section is academic, as MSVC doesn't support indirect gotos.
    600 
    601 void indirect_jumps(void **ip) {
    602   static void *ips[] = { &&l };
    603 
    604   __try { // expected-note {{jump exits __try block}}
    605     // FIXME: Should this be allowed? Jumping out of the guarded section of a
    606     // __try/__except doesn't require unwinding.
    607     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
    608   } __except(0) {
    609   }
    610 
    611   __try {
    612   } __except(0) { // expected-note {{jump exits __except block}}
    613     // FIXME: What about here?
    614     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
    615   }
    616 
    617   __try { // expected-note {{jump exits __try block}}
    618     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
    619   } __finally {
    620   }
    621 
    622   __try {
    623   } __finally { // expected-note {{jump exits __finally block}}
    624     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
    625   }
    626 l: // expected-note 4 {{possible target of indirect goto statement}}
    627   ;
    628 }
    629 
    630 } // namespace seh
    631