1 // RUN: %clang_cc1 -analyze -analyzer-checker=core,experimental.deadcode.UnreachableCode,experimental.unix.Malloc -verify -analyzer-constraints=basic %s 2 // RUN: %clang_cc1 -analyze -analyzer-checker=core,experimental.deadcode.UnreachableCode,experimental.unix.Malloc -verify -analyzer-constraints=range %s 3 4 // These are used to trigger warnings. 5 typedef typeof(sizeof(int)) size_t; 6 void *malloc(size_t); 7 void free(void *); 8 #define NULL ((void*)0) 9 #define UINT_MAX -1U 10 11 //--------------- 12 // Plus/minus 13 //--------------- 14 15 void separateExpressions (int a) { 16 int b = a + 1; 17 --b; 18 19 char* buf = malloc(1); 20 if (a != 0 && b == 0) 21 return; // expected-warning{{never executed}} 22 free(buf); 23 } 24 25 void oneLongExpression (int a) { 26 // Expression canonicalization should still allow this to work, even though 27 // the first term is on the left. 28 int b = 15 + a + 15 - 10 - 20; 29 30 char* buf = malloc(1); 31 if (a != 0 && b == 0) 32 return; // expected-warning{{never executed}} 33 free(buf); 34 } 35 36 void mixedTypes (int a) { 37 char* buf = malloc(1); 38 39 // Different additive types should not cause crashes when constant-folding. 40 // This is part of PR7406. 41 int b = a + 1LL; 42 if (a != 0 && (b-1) == 0) // not crash 43 return; // expected-warning{{never executed}} 44 45 int c = a + 1U; 46 if (a != 0 && (c-1) == 0) // not crash 47 return; // expected-warning{{never executed}} 48 49 free(buf); 50 } 51 52 //--------------- 53 // Comparisons 54 //--------------- 55 56 // Equality and inequality only 57 void eq_ne (unsigned a) { 58 char* b = NULL; 59 if (a == UINT_MAX) 60 b = malloc(1); 61 if (a+1 != 0) 62 return; // no-warning 63 if (a-1 != UINT_MAX-1) 64 return; // no-warning 65 free(b); 66 } 67 68 void ne_eq (unsigned a) { 69 char* b = NULL; 70 if (a != UINT_MAX) 71 b = malloc(1); 72 if (a+1 == 0) 73 return; // no-warning 74 if (a-1 == UINT_MAX-1) 75 return; // no-warning 76 free(b); 77 } 78 79 // Mixed typed inequalities (part of PR7406) 80 // These should not crash. 81 void mixed_eq_ne (int a) { 82 char* b = NULL; 83 if (a == 1) 84 b = malloc(1); 85 if (a+1U != 2) 86 return; // no-warning 87 if (a-1U != 0) 88 return; // expected-warning{{never executed}} 89 free(b); 90 } 91 92 void mixed_ne_eq (int a) { 93 char* b = NULL; 94 if (a != 1) 95 b = malloc(1); 96 if (a+1U == 2) 97 return; // no-warning 98 if (a-1U == 0) 99 return; // expected-warning{{never executed}} 100 free(b); 101 } 102 103 104 // Simple order comparisons with no adjustment 105 void baselineGT (unsigned a) { 106 char* b = NULL; 107 if (a > 0) 108 b = malloc(1); 109 if (a == 0) 110 return; // no-warning 111 free(b); 112 } 113 114 void baselineGE (unsigned a) { 115 char* b = NULL; 116 if (a >= UINT_MAX) 117 b = malloc(1); 118 if (a == UINT_MAX) 119 free(b); 120 return; // no-warning 121 } 122 123 void baselineLT (unsigned a) { 124 char* b = NULL; 125 if (a < UINT_MAX) 126 b = malloc(1); 127 if (a == UINT_MAX) 128 return; // no-warning 129 free(b); 130 } 131 132 void baselineLE (unsigned a) { 133 char* b = NULL; 134 if (a <= 0) 135 b = malloc(1); 136 if (a == 0) 137 free(b); 138 return; // no-warning 139 } 140 141 142 // Adjustment gives each of these an extra solution! 143 void adjustedGT (unsigned a) { 144 char* b = NULL; 145 if (a-1 > UINT_MAX-1) 146 b = malloc(1); 147 return; // expected-warning{{leak}} 148 } 149 150 void adjustedGE (unsigned a) { 151 char* b = NULL; 152 if (a-1 >= UINT_MAX-1) 153 b = malloc(1); 154 if (a == UINT_MAX) 155 free(b); 156 return; // expected-warning{{leak}} 157 } 158 159 void adjustedLT (unsigned a) { 160 char* b = NULL; 161 if (a+1 < 1) 162 b = malloc(1); 163 return; // expected-warning{{leak}} 164 } 165 166 void adjustedLE (unsigned a) { 167 char* b = NULL; 168 if (a+1 <= 1) 169 b = malloc(1); 170 if (a == 0) 171 free(b); 172 return; // expected-warning{{leak}} 173 } 174 175 176 // Tautologies 177 void tautologyGT (unsigned a) { 178 char* b = malloc(1); 179 if (a > UINT_MAX) 180 return; // no-warning 181 free(b); 182 } 183 184 void tautologyGE (unsigned a) { 185 char* b = malloc(1); 186 if (a >= 0) // expected-warning{{always true}} 187 free(b); 188 return; // no-warning 189 } 190 191 void tautologyLT (unsigned a) { 192 char* b = malloc(1); 193 if (a < 0) // expected-warning{{always false}} 194 return; // expected-warning{{never executed}} 195 free(b); 196 } 197 198 void tautologyLE (unsigned a) { 199 char* b = malloc(1); 200 if (a <= UINT_MAX) 201 free(b); 202 return; // no-warning 203 } 204
