1 // RUN: %check_clang_tidy %s bugprone-sizeof-expression %t -- -config="{CheckOptions: {bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression: true}}" -- 2 3 class C { 4 int size() { return sizeof(this); } 5 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(this)' 6 }; 7 8 #define LEN 8 9 10 int X; 11 extern int A[10]; 12 extern short B[10]; 13 14 #pragma pack(1) 15 struct S { char a, b, c; }; 16 17 enum E { E_VALUE = 0 }; 18 enum class EC { VALUE = 0 }; 19 20 bool AsBool() { return false; } 21 int AsInt() { return 0; } 22 E AsEnum() { return E_VALUE; } 23 EC AsEnumClass() { return EC::VALUE; } 24 S AsStruct() { return {}; } 25 26 struct M { 27 int AsInt() { return 0; } 28 E AsEnum() { return E_VALUE; } 29 S AsStruct() { return {}; } 30 }; 31 32 int ReturnOverload(int) { return {}; } 33 S ReturnOverload(S) { return {}; } 34 35 template <class T> 36 T ReturnTemplate(T) { return {}; } 37 38 template <class T> 39 bool TestTrait1() { 40 return sizeof(ReturnOverload(T{})) == sizeof(A); 41 } 42 43 template <class T> 44 bool TestTrait2() { 45 return sizeof(ReturnTemplate(T{})) == sizeof(A); 46 } 47 48 template <class T> 49 bool TestTrait3() { 50 return sizeof(ReturnOverload(0)) == sizeof(T{}); 51 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 52 } 53 54 template <class T> 55 bool TestTrait4() { 56 return sizeof(ReturnTemplate(0)) == sizeof(T{}); 57 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 58 } 59 60 bool TestTemplates() { 61 bool b = true; 62 b &= TestTrait1<int>(); 63 b &= TestTrait1<S>(); 64 b &= TestTrait2<int>(); 65 b &= TestTrait2<S>(); 66 b &= TestTrait3<int>(); 67 b &= TestTrait3<S>(); 68 b &= TestTrait4<int>(); 69 b &= TestTrait4<S>(); 70 return b; 71 } 72 73 int Test1(const char* ptr) { 74 int sum = 0; 75 sum += sizeof(LEN); 76 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(K)' 77 sum += sizeof(LEN + 1); 78 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(K)' 79 sum += sizeof(sum, LEN); 80 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: suspicious usage of 'sizeof(..., ...)' 81 sum += sizeof(AsBool()); 82 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 83 sum += sizeof(AsInt()); 84 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 85 sum += sizeof(AsEnum()); 86 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 87 sum += sizeof(AsEnumClass()); 88 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 89 sum += sizeof(M{}.AsInt()); 90 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 91 sum += sizeof(M{}.AsEnum()); 92 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of integer type 93 sum += sizeof(sizeof(X)); 94 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(sizeof(...))' 95 sum += sizeof(LEN + sizeof(X)); 96 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(sizeof(...))' 97 sum += sizeof(LEN + LEN + sizeof(X)); 98 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(sizeof(...))' 99 sum += sizeof(LEN + (LEN + sizeof(X))); 100 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(sizeof(...))' 101 sum += sizeof(LEN + -sizeof(X)); 102 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(sizeof(...))' 103 sum += sizeof(LEN + - + -sizeof(X)); 104 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(sizeof(...))' 105 sum += sizeof(char) / sizeof(char); 106 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have the same type 107 sum += sizeof(A) / sizeof(S); 108 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; numerator is not a multiple of denominator 109 sum += sizeof(char) / sizeof(int); 110 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; numerator is not a multiple of denominator 111 sum += sizeof(char) / sizeof(A); 112 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; numerator is not a multiple of denominator 113 sum += sizeof(B[0]) / sizeof(A); 114 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; numerator is not a multiple of denominator 115 sum += sizeof(ptr) / sizeof(char); 116 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; size of pointer is divided by size of pointed type 117 sum += sizeof(ptr) / sizeof(ptr[0]); 118 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; size of pointer is divided by size of pointed type 119 sum += sizeof(ptr) / sizeof(char*); 120 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have pointer types 121 sum += sizeof(ptr) / sizeof(void*); 122 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have pointer types 123 sum += sizeof(ptr) / sizeof(const void volatile*); 124 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have pointer types 125 sum += sizeof(ptr) / sizeof(char); 126 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; size of pointer is divided by size of pointed type 127 sum += sizeof(int) * sizeof(char); 128 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious 'sizeof' by 'sizeof' multiplication 129 sum += sizeof(ptr) * sizeof(ptr[0]); 130 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious 'sizeof' by 'sizeof' multiplication 131 sum += sizeof(int) * (2 * sizeof(char)); 132 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious 'sizeof' by 'sizeof' multiplication 133 sum += (2 * sizeof(char)) * sizeof(int); 134 // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: suspicious 'sizeof' by 'sizeof' multiplication 135 if (sizeof(A) < 0x100000) sum += 42; 136 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: suspicious comparison of 'sizeof(expr)' to a constant 137 if (sizeof(A) <= 0xFFFFFFFEU) sum += 42; 138 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: suspicious comparison of 'sizeof(expr)' to a constant 139 return sum; 140 } 141 142 typedef char MyChar; 143 typedef const MyChar MyConstChar; 144 145 int CE0 = sizeof sizeof(char); 146 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: suspicious usage of 'sizeof(sizeof(...))' 147 int CE1 = sizeof +sizeof(char); 148 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: suspicious usage of 'sizeof(sizeof(...))' 149 int CE2 = sizeof sizeof(const char*); 150 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: suspicious usage of 'sizeof(sizeof(...))' 151 int CE3 = sizeof sizeof(const volatile char* const*); 152 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: suspicious usage of 'sizeof(sizeof(...))' 153 int CE4 = sizeof sizeof(MyConstChar); 154 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: suspicious usage of 'sizeof(sizeof(...))' 155 156 int Test2(MyConstChar* A) { 157 int sum = 0; 158 sum += sizeof(MyConstChar) / sizeof(char); 159 // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have the same type 160 sum += sizeof(MyConstChar) / sizeof(MyChar); 161 // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have the same type 162 sum += sizeof(A[0]) / sizeof(char); 163 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have the same type 164 return sum; 165 } 166 167 template <int T> 168 int Foo() { int A[T]; return sizeof(T); } 169 // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: suspicious usage of 'sizeof(K)' 170 template <typename T> 171 int Bar() { T A[5]; return sizeof(A[0]) / sizeof(T); } 172 // CHECK-MESSAGES: :[[@LINE-1]]:41: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have the same type 173 int Test3() { return Foo<42>() + Bar<char>(); } 174 175 static const char* kABC = "abc"; 176 static const wchar_t* kDEF = L"def"; 177 int Test4(const char A[10]) { 178 int sum = 0; 179 sum += sizeof(kABC); 180 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(char*)' 181 sum += sizeof(kDEF); 182 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(char*)' 183 return sum; 184 } 185 186 int Test5() { 187 typedef int Array10[10]; 188 typedef C ArrayC[10]; 189 190 struct MyStruct { 191 Array10 arr; 192 Array10* ptr; 193 }; 194 typedef const MyStruct TMyStruct; 195 typedef const MyStruct *PMyStruct; 196 typedef TMyStruct *PMyStruct2; 197 198 static TMyStruct kGlocalMyStruct = {}; 199 static TMyStruct volatile * kGlocalMyStructPtr = &kGlocalMyStruct; 200 201 MyStruct S; 202 PMyStruct PS; 203 PMyStruct2 PS2; 204 Array10 A10; 205 C *PtrArray[10]; 206 C *PC; 207 208 char *PChar; 209 int *PInt, **PPInt; 210 MyStruct **PPMyStruct; 211 212 int sum = 0; 213 sum += sizeof(&S.arr); 214 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 215 sum += sizeof(&kGlocalMyStruct.arr); 216 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 217 sum += sizeof(&kGlocalMyStructPtr->arr); 218 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 219 sum += sizeof(S.arr + 0); 220 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 221 sum += sizeof(+ S.arr); 222 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 223 sum += sizeof((int*)S.arr); 224 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 225 226 sum += sizeof(S.ptr); 227 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 228 sum += sizeof(kGlocalMyStruct.ptr); 229 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 230 sum += sizeof(kGlocalMyStructPtr->ptr); 231 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 232 233 sum += sizeof(&kGlocalMyStruct); 234 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 235 sum += sizeof(&S); 236 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 237 sum += sizeof(MyStruct*); 238 sum += sizeof(PMyStruct); 239 sum += sizeof(PS); 240 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 241 sum += sizeof(PS2); 242 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 243 sum += sizeof(&A10); 244 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 245 sum += sizeof(PtrArray) / sizeof(PtrArray[1]); 246 // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: suspicious usage of 'sizeof()' on an expression of pointer type 247 sum += sizeof(A10) / sizeof(PtrArray[0]); 248 sum += sizeof(PC) / sizeof(PtrArray[0]); 249 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof()' on an expression of pointer type 250 // CHECK-MESSAGES: :[[@LINE-2]]:21: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; both expressions have the same type 251 sum += sizeof(ArrayC) / sizeof(PtrArray[0]); 252 // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: suspicious usage of 'sizeof(...)/sizeof(...)'; numerator is not a multiple of denominator 253 254 // These pointers do not point to aggregate types, so they are not reported in this mode: 255 sum += sizeof(PChar); 256 sum += sizeof(PInt); 257 sum += sizeof(PPInt); 258 sum += sizeof(PPMyStruct); 259 260 return sum; 261 } 262 263 int Test6() { 264 int sum = 0; 265 266 struct S A = AsStruct(), B = AsStruct(); 267 struct S *P = &A, *Q = &B; 268 sum += sizeof(struct S) == P - Q; 269 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 270 sum += 5 * sizeof(S) != P - Q; 271 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 272 sum += sizeof(S) < P - Q; 273 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 274 sum += 5 * sizeof(S) <= P - Q; 275 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 276 sum += 5 * sizeof(*P) >= P - Q; 277 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 278 sum += Q - P > 3 * sizeof(*P); 279 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 280 sum += sizeof(S) + (P - Q); 281 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 282 sum += 5 * sizeof(S) - (P - Q); 283 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 284 sum += (P - Q) / sizeof(S); 285 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 286 sum += (P - Q) / sizeof(*Q); 287 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: suspicious usage of 'sizeof(...)' in pointer arithmetic 288 289 return sum; 290 } 291 292 #ifdef __SIZEOF_INT128__ 293 template <__int128_t N> 294 #else 295 template <long N> // Fallback for platforms which do not define `__int128_t` 296 #endif 297 bool Baz() { return sizeof(A) < N; } 298 // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: suspicious comparison of 'sizeof(expr)' to a constant 299 bool Test7() { return Baz<-1>(); } 300 301 void some_generic_function(const void *arg, int argsize); 302 int *IntP, **IntPP; 303 C *ClassP, **ClassPP; 304 305 void GenericFunctionTest() { 306 // The `sizeof(pointer)` checks ignore situations where the pointer is 307 // produced by dereferencing a pointer-to-pointer, because this is unlikely 308 // to be an accident and can appear in legitimate code that tries to call 309 // a generic function which emulates dynamic typing within C. 310 some_generic_function(IntPP, sizeof(*IntPP)); 311 some_generic_function(ClassPP, sizeof(*ClassPP)); 312 // Using `...[0]` instead of the dereference operator is another common 313 // variant, which is also widespread in the idiomatic array-size calculation: 314 // `sizeof(array) / sizeof(array[0])`. 315 some_generic_function(IntPP, sizeof(IntPP[0])); 316 some_generic_function(ClassPP, sizeof(ClassPP[0])); 317 // FIXME: There is a third common pattern where the generic function is 318 // called with `&Variable` and `sizeof(Variable)`. Right now these are 319 // reported by the `sizeof(pointer)` checks, but this causes some false 320 // positives, so it would be good to create an exception for them. 321 // NOTE: `sizeof(IntP)` is only reported with `WarnOnSizeOfPointer=true`. 322 some_generic_function(&IntPP, sizeof(IntP)); 323 some_generic_function(&ClassPP, sizeof(ClassP)); 324 // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: suspicious usage of 'sizeof()' on an expression of pointer type 325 } 326 327 int ValidExpressions() { 328 int A[] = {1, 2, 3, 4}; 329 static const char str[] = "hello"; 330 static const char* ptr[] { "aaa", "bbb", "ccc" }; 331 typedef C *CA10[10]; 332 C *PtrArray[10]; 333 CA10 PtrArray1; 334 335 int sum = 0; 336 if (sizeof(A) < 10) 337 sum += sizeof(A); 338 sum += sizeof(int); 339 sum += sizeof(AsStruct()); 340 sum += sizeof(M{}.AsStruct()); 341 sum += sizeof(A[sizeof(A) / sizeof(int)]); 342 sum += sizeof(&A[sizeof(A) / sizeof(int)]); 343 sum += sizeof(sizeof(0)); // Special case: sizeof size_t. 344 sum += sizeof(void*); 345 sum += sizeof(void const *); 346 sum += sizeof(void const *) / 4; 347 sum += sizeof(str); 348 sum += sizeof(str) / sizeof(char); 349 sum += sizeof(str) / sizeof(str[0]); 350 sum += sizeof(ptr) / sizeof(ptr[0]); 351 sum += sizeof(ptr) / sizeof(*(ptr)); 352 sum += sizeof(PtrArray) / sizeof(PtrArray[0]); 353 // Canonical type of PtrArray1 is same as PtrArray. 354 sum = sizeof(PtrArray) / sizeof(PtrArray1[0]); 355 // There is no warning for 'sizeof(T*)/sizeof(Q)' case. 356 sum += sizeof(PtrArray) / sizeof(A[0]); 357 return sum; 358 } 359