Home | History | Annotate | Download | only in Sema 
      1 // RUN: %clang %s -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -Xclang -verify -fblocks -Wno-unreachable-code -Wno-unused-value
      2 
      3 // clang emits the following warning by default.
      4 // With GCC, -pedantic, -Wreturn-type or -Wall are required to produce the
      5 // following warning.
      6 int t14() {
      7   return; // expected-warning {{non-void function 't14' should return a value}}
      8 }
      9 
     10 void t15() {
     11   return 1; // expected-warning {{void function 't15' should not return a value}}
     12 }
     13 
     14 int unknown();
     15 
     16 void test0() {
     17 }
     18 
     19 int test1() {
     20 } // expected-warning {{control reaches end of non-void function}}
     21 
     22 int test2() {
     23   a: goto a;
     24 }
     25 
     26 int test3() {
     27   goto a;
     28   a: ;
     29 } // expected-warning {{control reaches end of non-void function}}
     30 
     31 
     32 void halt() {
     33   a: goto a;
     34 }
     35 
     36 void halt2() __attribute__((noreturn));
     37 
     38 int test4() {
     39   halt2();
     40 }
     41 
     42 int test5() {
     43   halt2(), (void)1;
     44 }
     45 
     46 int test6() {
     47   1, halt2();
     48 }
     49 
     50 int j;
     51 int unknown_nohalt() {
     52   return j;
     53 }
     54 
     55 int test7() {
     56   unknown();
     57 } // expected-warning {{control reaches end of non-void function}}
     58 
     59 int test8() {
     60   (void)(1 + unknown());
     61 } // expected-warning {{control reaches end of non-void function}}
     62 
     63 int halt3() __attribute__((noreturn));
     64 
     65 int test9() {
     66   (void)(halt3() + unknown());
     67 }
     68 
     69 int test10() {
     70   (void)(unknown() || halt3());
     71 } // expected-warning {{control may reach end of non-void function}}
     72 
     73 int test11() {
     74   (void)(unknown() && halt3());
     75 } // expected-warning {{control may reach end of non-void function}}
     76 
     77 int test12() {
     78   (void)(halt3() || unknown());
     79 }
     80 
     81 int test13() {
     82   (void)(halt3() && unknown());
     83 }
     84 
     85 int test14() {
     86   (void)(1 || unknown());
     87 } // expected-warning {{control reaches end of non-void function}}
     88 
     89 int test15() {
     90   (void)(0 || unknown());
     91 } // expected-warning {{control reaches end of non-void function}}
     92 
     93 int test16() {
     94   (void)(0 && unknown());
     95 } // expected-warning {{control reaches end of non-void function}}
     96 
     97 int test17() {
     98   (void)(1 && unknown());
     99 } // expected-warning {{control reaches end of non-void function}}
    100 
    101 int test18() {
    102   (void)(unknown_nohalt() && halt3());
    103 } // expected-warning {{control may reach end of non-void function}}
    104 
    105 int test19() {
    106   (void)(unknown_nohalt() && unknown());
    107 } // expected-warning {{control reaches end of non-void function}}
    108 
    109 int test20() {
    110   int i;
    111   if (i)
    112     return 0;
    113   else if (0)
    114     return 2;
    115 } // expected-warning {{control may reach end of non-void function}}
    116 
    117 int test21() {
    118   int i;
    119   if (i)
    120     return 0;
    121   else if (1)
    122     return 2;
    123 }
    124 
    125 int test22() {
    126   int i;
    127   switch (i) default: ;
    128 } // expected-warning {{control reaches end of non-void function}}
    129 
    130 int test23() {
    131   int i;
    132   switch (i) {
    133   case 0:
    134     return 0;
    135   case 2:
    136     return 2;
    137   }
    138 } // expected-warning {{control may reach end of non-void function}}
    139 
    140 int test24() {
    141   int i;
    142   switch (i) {
    143     case 0:
    144     return 0;
    145   case 2:
    146     return 2;
    147   default:
    148     return -1;
    149   }
    150 }
    151 
    152 int test25() {
    153   1 ? halt3() : unknown();
    154 }
    155 
    156 int test26() {
    157   0 ? halt3() : unknown();
    158 } // expected-warning {{control reaches end of non-void function}}
    159 
    160 int j;
    161 void (*fptr)() __attribute__((noreturn));
    162 int test27() {
    163   switch (j) {
    164   case 1:
    165     do { } while (1);
    166     break;
    167   case 2:
    168     for (;;) ;
    169     break;
    170   case 3:
    171     for (;1;) ;
    172     for (;0;) {
    173       goto done;
    174     }
    175     return 1;
    176   case 4:
    177     while (0) { goto done; }
    178     return 1;
    179   case 5:
    180     while (1) { return 1; }
    181     break;
    182   case 6:
    183     fptr();
    184     break;
    185   default:
    186     return 1;
    187   }
    188   done: ;
    189 }
    190 
    191 // PR4624
    192 void test28() __attribute__((noreturn));
    193 void test28(x) { while (1) { } }
    194 
    195 void exit(int);
    196 int test29() {
    197   exit(1);
    198 }
    199 
    200 // Include these declarations here explicitly so we don't depend on system headers.
    201 typedef struct __jmp_buf_tag{} jmp_buf[1];
    202 
    203 extern void longjmp (struct __jmp_buf_tag __env[1], int __val) __attribute__ ((noreturn));
    204 extern void _longjmp (struct __jmp_buf_tag __env[1], int __val) __attribute__ ((noreturn));
    205 
    206 jmp_buf test30_j;
    207 
    208 int test30() {
    209   if (j)
    210     longjmp(test30_j, 1);
    211   else
    212 #if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
    213     longjmp(test30_j, 2);
    214 #else
    215     _longjmp(test30_j, 1);
    216 #endif
    217 }
    218 
    219 typedef void test31_t(int status);
    220 void test31(test31_t *callback __attribute__((noreturn)));
    221 
    222 void test32() {
    223   ^ (void) { while (1) { } }();
    224   ^ (void) { if (j) while (1) { } }();
    225   while (1) { }
    226 }
    227 
    228 void test33() {
    229   if (j) while (1) { }
    230 }
    231 
    232 // Test that 'static inline' functions are only analyzed for CFG-based warnings
    233 // when they are used.
    234 static inline int si_has_missing_return() {} // expected-warning{{control reaches end of non-void function}}
    235 static inline int si_has_missing_return_2() {}; // expected-warning{{control reaches end of non-void function}}
    236 static inline int si_forward();
    237 static inline int si_has_missing_return_3(int x) {
    238   if (x)
    239    return si_has_missing_return_3(x+1);
    240 } // expected-warning{{control may reach end of non-void function}}
    241 
    242 int test_static_inline(int x) {
    243   si_forward();
    244   return x ? si_has_missing_return_2() : si_has_missing_return_3(x);
    245 }
    246 static inline int si_forward() {} // expected-warning{{control reaches end of non-void function}}
    247 
    248 // Test warnings on ignored qualifiers on return types.
    249 const int ignored_c_quals(); // expected-warning{{'const' type qualifier on return type has no effect}}
    250 const volatile int ignored_cv_quals(); // expected-warning{{'const volatile' type qualifiers on return type have no effect}}
    251 char* const volatile restrict ignored_cvr_quals(); // expected-warning{{'const volatile restrict' type qualifiers on return type have no effect}}
    252 
    253 typedef const int CI;
    254 CI ignored_quals_typedef();
    255 
    256 const CI ignored_quals_typedef_2(); // expected-warning{{'const' type qualifier}}
    257 
    258 // Test that for switch(enum) that if the switch statement covers all the cases
    259 // that we don't consider that for -Wreturn-type.
    260 enum Cases { C1, C2, C3, C4 };
    261 int test_enum_cases(enum Cases C) {
    262   switch (C) {
    263   case C1: return 1;
    264   case C2: return 2;
    265   case C4: return 3;
    266   case C3: return 4;
    267   }
    268 } // no-warning
    269 
    270 // PR12318 - Don't give a may reach end of non-void function warning.
    271 int test34(int x) {
    272   if (x == 1) {
    273     return 3;
    274   } else if ( x == 2 || 1) {
    275     return 5;
    276   }
    277 }
    278