maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Analysis/designated-initializer-valu...

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

39 lines
1.6 KiB
C
Raw Normal View History

[analyzer] Do not cache out on some shared implicit AST nodes Some AST nodes which stands for implicit initialization is shared. The analyzer will do the same evaluation on the same nodes resulting in the same state. The analyzer will "cache out", i.e. it thinks that it visited an already existing node in the exploded graph. This is not true in this case and we lose coverage. Since these nodes do not really require any processing from the analyzer we just omit them from the CFG. Differential Revision: https://reviews.llvm.org/D71371
2019-12-12 03:34:44 +08:00
// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c99 -verify %s
void clang_analyzer_eval(int);
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eighth batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-12 20:23:43 +08:00
void array_init(void) {
[analyzer] Do not cache out on some shared implicit AST nodes Some AST nodes which stands for implicit initialization is shared. The analyzer will do the same evaluation on the same nodes resulting in the same state. The analyzer will "cache out", i.e. it thinks that it visited an already existing node in the exploded graph. This is not true in this case and we lose coverage. Since these nodes do not really require any processing from the analyzer we just omit them from the CFG. Differential Revision: https://reviews.llvm.org/D71371
2019-12-12 03:34:44 +08:00
int a[5] = {[4] = 29, [2] = 15, [0] = 4};
clang_analyzer_eval(a[0] == 4); // expected-warning{{TRUE}}
clang_analyzer_eval(a[1] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(a[2] == 15); // expected-warning{{TRUE}}
clang_analyzer_eval(a[3] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(a[4] == 29); // expected-warning{{TRUE}}
int b[5] = {[0 ... 2] = 1, [4] = 5};
clang_analyzer_eval(b[0] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(b[1] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(b[2] == 1); // expected-warning{{TRUE}}
clang_analyzer_eval(b[3] == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(b[4] == 5); // expected-warning{{TRUE}}
}
struct point {
int x, y;
};
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eighth batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-12 20:23:43 +08:00
void struct_init(void) {
[analyzer] Do not cache out on some shared implicit AST nodes Some AST nodes which stands for implicit initialization is shared. The analyzer will do the same evaluation on the same nodes resulting in the same state. The analyzer will "cache out", i.e. it thinks that it visited an already existing node in the exploded graph. This is not true in this case and we lose coverage. Since these nodes do not really require any processing from the analyzer we just omit them from the CFG. Differential Revision: https://reviews.llvm.org/D71371
2019-12-12 03:34:44 +08:00
struct point p = {.y = 5, .x = 3};
clang_analyzer_eval(p.x == 3); // expected-warning{{TRUE}}
clang_analyzer_eval(p.y == 5); // expected-warning{{TRUE}}
}
Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eighth batch of tests being updated (there are a significant number of other tests left to be updated).
2022-02-12 20:23:43 +08:00
void array_of_struct(void) {
[analyzer] Do not cache out on some shared implicit AST nodes Some AST nodes which stands for implicit initialization is shared. The analyzer will do the same evaluation on the same nodes resulting in the same state. The analyzer will "cache out", i.e. it thinks that it visited an already existing node in the exploded graph. This is not true in this case and we lose coverage. Since these nodes do not really require any processing from the analyzer we just omit them from the CFG. Differential Revision: https://reviews.llvm.org/D71371
2019-12-12 03:34:44 +08:00
struct point ptarray[3] = { [2].y = 1, [2].x = 2, [0].x = 3 };
clang_analyzer_eval(ptarray[0].x == 3); // expected-warning{{TRUE}}
clang_analyzer_eval(ptarray[0].y == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(ptarray[1].x == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(ptarray[1].y == 0); // expected-warning{{TRUE}}
clang_analyzer_eval(ptarray[2].x == 2); // expected-warning{{TRUE}}
clang_analyzer_eval(ptarray[2].y == 1); // expected-warning{{TRUE}}
}