codeql/cpp/ql/test/library-tests/dataflow/dataflow-tests/BarrierGuard.cpp at codeql-cli/v2.26.0 · github/codeql · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
int source();
void sink(...);
bool guarded(int);

void bg_basic(int source) {
  if (guarded(source)) {
    sink(source);
  } else {
    sink(source); // $ ast,ir
  }
}

void bg_not(int source) {
  if (!guarded(source)) {
    sink(source); // $ ast,ir
  } else {
    sink(source);
  }
}

void bg_and(int source, bool arbitrary) {
  if (guarded(source) && arbitrary) {
    sink(source);
  } else {
    sink(source); // $ ast,ir
  }
}

void bg_or(int source, bool arbitrary) {
  if (guarded(source) || arbitrary) {
    sink(source); // $ ast,ir
  } else {
    sink(source); // $ ast,ir
  }
}

void bg_return(int source) {
  if (!guarded(source)) {
    return;
  }
  sink(source);
}

struct XY {
  int x, y;
};

void bg_stackstruct(XY s1, XY s2) {
  s1.x = source();
  if (guarded(s1.x)) {
    sink(s1.x); // $ SPURIOUS: ast
  } else if (guarded(s1.y)) {
    sink(s1.x); // $ ast,ir
  } else if (guarded(s2.y)) {
    sink(s1.x); // $ ast,ir
  }
}

void bg_structptr(XY *p1, XY *p2) { // $ ast-def=p1 ast-def=p2 ir-def=*p1 ir-def=*p2
  p1->x = source();
  if (guarded(p1->x)) {
    sink(p1->x); // $ SPURIOUS: ast
  } else if (guarded(p1->y)) {
    sink(p1->x); // $ ast,ir
  } else if (guarded(p2->x)) {
    sink(p1->x); // $ ast,ir
  }
}

int* indirect_source();
bool guarded(const int*);

void bg_indirect_expr() {
  int *buf = indirect_source();
  if (guarded(buf)) {
    sink(buf);
  }
}

void test_guard_and_reassign() {
  int x = source();

  if(!guarded(x)) {
    x = 0;
  }
  sink(x); // $ SPURIOUS: ast
}

void test_phi_read_guard(bool b) {
  int x = source();

  if(b) {
    if(!guarded(x))
      return;
  }
  else {
    if(!guarded(x))
      return;
  }

  sink(x); // $ SPURIOUS: ast
}

bool unsafe(int);

void test_guard_and_reassign_2() {
  int x = source();

  if(unsafe(x)) {
    x = 0;
  }
  sink(x); // $ SPURIOUS: ast
}

void test_phi_read_guard_2(bool b) {
  int x = source();

  if(b) {
    if(unsafe(x))
      return;
  }
  else {
    if(unsafe(x))
      return;
  }

  sink(x); // $ SPURIOUS: ast
}

bool guarded_wrapper(int x) {
  if(guarded(x)) {
    return true;
  } else {
    return false;
  }
}

bool guarded_wrapper_2(int x) {
  bool b;
  if(guarded(x)) {
    b = true;
  } else {
    b = false;
  }
  return b;
}

bool guarded_wrapper_3(int x) {
  bool b = false;
  if(guarded(x)) {
    b = true;
  }
  return b;
}

bool guarded_wrapper_4(int x) {
  bool b = false;
  if(guarded(x)) {
    return true;
  }
  return b;
}

void test_guarded_wrapper() {
  int x = source();

  if(guarded_wrapper(x)) {
    sink(x); // $ SPURIOUS: ast
  } else {
    sink(x); // $ ast,ir
  }

  if(guarded_wrapper_2(x)) {
    sink(x); // $ SPURIOUS: ast
  } else {
    sink(x); // $ ast,ir
  }

  if(guarded_wrapper_3(x)) {
    sink(x); // $ SPURIOUS: ast
  } else {
    sink(x); // $ ast,ir
  }

  if(guarded_wrapper_4(x)) {
    sink(x); // $ SPURIOUS: ast
  } else {
    sink(x); // $ ast,ir
  }
}