Branch data Line data Source code
1 : : /* Handling for the known behavior of various specific functions.
2 : : Copyright (C) 2020-2024 Free Software Foundation, Inc.
3 : : Contributed by David Malcolm <dmalcolm@redhat.com>.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it
8 : : under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but
13 : : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #include "config.h"
22 : : #define INCLUDE_VECTOR
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "tree.h"
26 : : #include "function.h"
27 : : #include "basic-block.h"
28 : : #include "gimple.h"
29 : : #include "diagnostic-core.h"
30 : : #include "diagnostic-metadata.h"
31 : : #include "analyzer/analyzer.h"
32 : : #include "analyzer/analyzer-logging.h"
33 : : #include "diagnostic.h"
34 : : #include "analyzer/region-model.h"
35 : : #include "analyzer/call-details.h"
36 : : #include "analyzer/call-info.h"
37 : : #include "make-unique.h"
38 : :
39 : : #if ENABLE_ANALYZER
40 : :
41 : : namespace ana {
42 : :
43 : : /* Abstract subclass for describing undefined behavior of an API. */
44 : :
45 : : class undefined_function_behavior
46 : : : public pending_diagnostic_subclass<undefined_function_behavior>
47 : : {
48 : : public:
49 : 8 : undefined_function_behavior (const call_details &cd)
50 : 8 : : m_call_stmt (cd.get_call_stmt ()),
51 : 8 : m_callee_fndecl (cd.get_fndecl_for_call ())
52 : : {
53 : 8 : gcc_assert (m_call_stmt);
54 : 8 : gcc_assert (m_callee_fndecl);
55 : 8 : }
56 : :
57 : 28 : const char *get_kind () const final override
58 : : {
59 : 28 : return "undefined_behavior";
60 : : }
61 : :
62 : 8 : bool operator== (const undefined_function_behavior &other) const
63 : : {
64 : 8 : return (m_call_stmt == other.m_call_stmt
65 : 8 : && m_callee_fndecl == other.m_callee_fndecl);
66 : : }
67 : :
68 : 8 : bool terminate_path_p () const final override { return true; }
69 : :
70 : 16 : tree get_callee_fndecl () const { return m_callee_fndecl; }
71 : :
72 : : private:
73 : : const gimple *m_call_stmt;
74 : : tree m_callee_fndecl;
75 : : };
76 : :
77 : : /* class pure_known_function_with_default_return : public known_function. */
78 : :
79 : : void
80 : 2116 : pure_known_function_with_default_return::
81 : : impl_call_pre (const call_details &cd) const
82 : : {
83 : 2116 : cd.set_any_lhs_with_defaults ();
84 : 2116 : }
85 : :
86 : : /* Implementations of specific functions. */
87 : :
88 : : /* Handler for "alloca". */
89 : :
90 : 9597 : class kf_alloca : public builtin_known_function
91 : : {
92 : : public:
93 : 1231 : bool matches_call_types_p (const call_details &cd) const final override
94 : : {
95 : 1231 : return cd.num_args () == 1;
96 : : }
97 : 2422 : enum built_in_function builtin_code () const final override
98 : : {
99 : 2422 : return BUILT_IN_ALLOCA;
100 : : }
101 : : void impl_call_pre (const call_details &cd) const final override;
102 : : };
103 : :
104 : : void
105 : 534 : kf_alloca::impl_call_pre (const call_details &cd) const
106 : : {
107 : 534 : const svalue *size_sval = cd.get_arg_svalue (0);
108 : :
109 : 534 : region_model *model = cd.get_model ();
110 : 534 : region_model_manager *mgr = cd.get_manager ();
111 : :
112 : 534 : const region *new_reg
113 : 534 : = model->create_region_for_alloca (size_sval, cd.get_ctxt ());
114 : 534 : const svalue *ptr_sval
115 : 534 : = mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
116 : 534 : cd.maybe_set_lhs (ptr_sval);
117 : 534 : }
118 : :
119 : : /* Handler for __atomic_exchange.
120 : : Although the user-facing documentation specifies it as having this
121 : : signature:
122 : : void __atomic_exchange (type *ptr, type *val, type *ret, int memorder)
123 : :
124 : : by the time the C/C++ frontends have acted on it, any calls that
125 : : can't be mapped to a _N variation end up with this signature:
126 : :
127 : : void
128 : : __atomic_exchange (size_t sz, void *ptr, void *val, void *ret,
129 : : int memorder)
130 : :
131 : : as seen in the gimple seen by the analyzer, and as specified
132 : : in sync-builtins.def. */
133 : :
134 : 6398 : class kf_atomic_exchange : public internal_known_function
135 : : {
136 : : public:
137 : : /* This is effectively:
138 : : tmpA = *PTR;
139 : : tmpB = *VAL;
140 : : *PTR = tmpB;
141 : : *RET = tmpA;
142 : : */
143 : 4 : void impl_call_pre (const call_details &cd) const final override
144 : : {
145 : 4 : const svalue *num_bytes_sval = cd.get_arg_svalue (0);
146 : 4 : const svalue *ptr_sval = cd.get_arg_svalue (1);
147 : 4 : tree ptr_tree = cd.get_arg_tree (1);
148 : 4 : const svalue *val_sval = cd.get_arg_svalue (2);
149 : 4 : tree val_tree = cd.get_arg_tree (2);
150 : 4 : const svalue *ret_sval = cd.get_arg_svalue (3);
151 : 4 : tree ret_tree = cd.get_arg_tree (3);
152 : : /* Ignore the memorder param. */
153 : :
154 : 4 : region_model *model = cd.get_model ();
155 : 4 : region_model_context *ctxt = cd.get_ctxt ();
156 : :
157 : 4 : const region *ptr_reg = model->deref_rvalue (ptr_sval, ptr_tree, ctxt);
158 : 4 : const region *val_reg = model->deref_rvalue (val_sval, val_tree, ctxt);
159 : 4 : const region *ret_reg = model->deref_rvalue (ret_sval, ret_tree, ctxt);
160 : :
161 : 4 : const svalue *tmp_a_sval
162 : 4 : = model->read_bytes (ptr_reg, ptr_tree, num_bytes_sval, ctxt);
163 : 4 : const svalue *tmp_b_sval
164 : 4 : = model->read_bytes (val_reg, val_tree, num_bytes_sval, ctxt);
165 : 4 : model->write_bytes (ptr_reg, num_bytes_sval, tmp_b_sval, ctxt);
166 : 4 : model->write_bytes (ret_reg, num_bytes_sval, tmp_a_sval, ctxt);
167 : 4 : }
168 : : };
169 : :
170 : : /* Handler for:
171 : : __atomic_exchange_n (type *ptr, type val, int memorder). */
172 : :
173 : 38388 : class kf_atomic_exchange_n : public internal_known_function
174 : : {
175 : : public:
176 : : /* This is effectively:
177 : : RET = *PTR;
178 : : *PTR = VAL;
179 : : return RET;
180 : : */
181 : 23 : void impl_call_pre (const call_details &cd) const final override
182 : : {
183 : 23 : const svalue *ptr_sval = cd.get_arg_svalue (0);
184 : 23 : tree ptr_tree = cd.get_arg_tree (0);
185 : 23 : const svalue *set_sval = cd.get_arg_svalue (1);
186 : : /* Ignore the memorder param. */
187 : :
188 : 23 : region_model *model = cd.get_model ();
189 : 23 : region_model_context *ctxt = cd.get_ctxt ();
190 : :
191 : 23 : const region *dst_region = model->deref_rvalue (ptr_sval, ptr_tree, ctxt);
192 : 23 : const svalue *ret_sval = model->get_store_value (dst_region, ctxt);
193 : 23 : model->set_value (dst_region, set_sval, ctxt);
194 : 23 : cd.maybe_set_lhs (ret_sval);
195 : 23 : }
196 : : };
197 : :
198 : : /* Handler for:
199 : : type __atomic_fetch_add (type *ptr, type val, int memorder);
200 : : type __atomic_fetch_sub (type *ptr, type val, int memorder);
201 : : type __atomic_fetch_and (type *ptr, type val, int memorder);
202 : : type __atomic_fetch_xor (type *ptr, type val, int memorder);
203 : : type __atomic_fetch_or (type *ptr, type val, int memorder);
204 : : */
205 : :
206 : : class kf_atomic_fetch_op : public internal_known_function
207 : : {
208 : : public:
209 : 159950 : kf_atomic_fetch_op (enum tree_code op): m_op (op) {}
210 : :
211 : : /* This is effectively:
212 : : RET = *PTR;
213 : : *PTR = RET OP VAL;
214 : : return RET;
215 : : */
216 : 75 : void impl_call_pre (const call_details &cd) const final override
217 : : {
218 : 75 : const svalue *ptr_sval = cd.get_arg_svalue (0);
219 : 75 : tree ptr_tree = cd.get_arg_tree (0);
220 : 75 : const svalue *val_sval = cd.get_arg_svalue (1);
221 : : /* Ignore the memorder param. */
222 : :
223 : 75 : region_model *model = cd.get_model ();
224 : 75 : region_model_manager *mgr = cd.get_manager ();
225 : 75 : region_model_context *ctxt = cd.get_ctxt ();
226 : :
227 : 75 : const region *star_ptr_region
228 : 75 : = model->deref_rvalue (ptr_sval, ptr_tree, ctxt);
229 : 75 : const svalue *old_sval = model->get_store_value (star_ptr_region, ctxt);
230 : 150 : const svalue *new_sval = mgr->get_or_create_binop (old_sval->get_type (),
231 : 75 : m_op,
232 : : old_sval, val_sval);
233 : 75 : model->set_value (star_ptr_region, new_sval, ctxt);
234 : 75 : cd.maybe_set_lhs (old_sval);
235 : 75 : }
236 : :
237 : : private:
238 : : enum tree_code m_op;
239 : : };
240 : :
241 : : /* Handler for:
242 : : type __atomic_add_fetch (type *ptr, type val, int memorder);
243 : : type __atomic_sub_fetch (type *ptr, type val, int memorder);
244 : : type __atomic_and_fetch (type *ptr, type val, int memorder);
245 : : type __atomic_xor_fetch (type *ptr, type val, int memorder);
246 : : type __atomic_or_fetch (type *ptr, type val, int memorder);
247 : : */
248 : :
249 : : class kf_atomic_op_fetch : public internal_known_function
250 : : {
251 : : public:
252 : 159950 : kf_atomic_op_fetch (enum tree_code op): m_op (op) {}
253 : :
254 : : /* This is effectively:
255 : : *PTR = RET OP VAL;
256 : : return *PTR;
257 : : */
258 : 10 : void impl_call_pre (const call_details &cd) const final override
259 : : {
260 : 10 : const svalue *ptr_sval = cd.get_arg_svalue (0);
261 : 10 : tree ptr_tree = cd.get_arg_tree (0);
262 : 10 : const svalue *val_sval = cd.get_arg_svalue (1);
263 : : /* Ignore the memorder param. */
264 : :
265 : 10 : region_model *model = cd.get_model ();
266 : 10 : region_model_manager *mgr = cd.get_manager ();
267 : 10 : region_model_context *ctxt = cd.get_ctxt ();
268 : :
269 : 10 : const region *star_ptr_region
270 : 10 : = model->deref_rvalue (ptr_sval, ptr_tree, ctxt);
271 : 10 : const svalue *old_sval = model->get_store_value (star_ptr_region, ctxt);
272 : 20 : const svalue *new_sval = mgr->get_or_create_binop (old_sval->get_type (),
273 : 10 : m_op,
274 : : old_sval, val_sval);
275 : 10 : model->set_value (star_ptr_region, new_sval, ctxt);
276 : 10 : cd.maybe_set_lhs (new_sval);
277 : 10 : }
278 : :
279 : : private:
280 : : enum tree_code m_op;
281 : : };
282 : :
283 : : /* Handler for __atomic_load.
284 : : Although the user-facing documentation specifies it as having this
285 : : signature:
286 : :
287 : : void __atomic_load (type *ptr, type *ret, int memorder)
288 : :
289 : : by the time the C/C++ frontends have acted on it, any calls that
290 : : can't be mapped to a _N variation end up with this signature:
291 : :
292 : : void __atomic_load (size_t sz, const void *src, void *dst, int memorder);
293 : :
294 : : as seen in the gimple seen by the analyzer, and as specified
295 : : in sync-builtins.def. */
296 : :
297 : 6398 : class kf_atomic_load : public internal_known_function
298 : : {
299 : : public:
300 : : /* This is effectively:
301 : : memmove (dst, src, sz);
302 : : */
303 : 12 : void impl_call_pre (const call_details &cd) const final override
304 : : {
305 : 12 : const svalue *num_bytes_sval = cd.get_arg_svalue (0);
306 : 12 : const svalue *src_sval = cd.get_arg_svalue (1);
307 : 12 : tree src_tree = cd.get_arg_tree (1);
308 : 12 : const svalue *dst_sval = cd.get_arg_svalue (2);
309 : 12 : tree dst_tree = cd.get_arg_tree (2);
310 : : /* Ignore the memorder param. */
311 : :
312 : 12 : region_model *model = cd.get_model ();
313 : 12 : region_model_context *ctxt = cd.get_ctxt ();
314 : :
315 : 12 : const region *dst_reg = model->deref_rvalue (dst_sval, dst_tree, ctxt);
316 : 12 : const region *src_reg = model->deref_rvalue (src_sval, src_tree, ctxt);
317 : :
318 : 12 : const svalue *data_sval
319 : 12 : = model->read_bytes (src_reg, src_tree, num_bytes_sval, ctxt);
320 : 12 : model->write_bytes (dst_reg, num_bytes_sval, data_sval, ctxt);
321 : 12 : }
322 : : };
323 : :
324 : : /* Handler for __atomic_store.
325 : : Although the user-facing documentation specifies it as having this
326 : : signature:
327 : :
328 : : void __atomic_store (type *ptr, type *val, int memorder)
329 : :
330 : : by the time the C/C++ frontends have acted on it, any calls that
331 : : can't be mapped to a _N variation end up with this signature:
332 : :
333 : : void __atomic_store (size_t sz, type *dst, type *src, int memorder)
334 : :
335 : : as seen in the gimple seen by the analyzer, and as specified
336 : : in sync-builtins.def. */
337 : :
338 : 6398 : class kf_atomic_store : public internal_known_function
339 : : {
340 : : public:
341 : : /* This is effectively:
342 : : memmove (dst, src, sz);
343 : : */
344 : 4 : void impl_call_pre (const call_details &cd) const final override
345 : : {
346 : 4 : const svalue *num_bytes_sval = cd.get_arg_svalue (0);
347 : 4 : const svalue *dst_sval = cd.get_arg_svalue (1);
348 : 4 : tree dst_tree = cd.get_arg_tree (1);
349 : 4 : const svalue *src_sval = cd.get_arg_svalue (2);
350 : 4 : tree src_tree = cd.get_arg_tree (2);
351 : : /* Ignore the memorder param. */
352 : :
353 : 4 : region_model *model = cd.get_model ();
354 : 4 : region_model_context *ctxt = cd.get_ctxt ();
355 : :
356 : 4 : const region *dst_reg = model->deref_rvalue (dst_sval, dst_tree, ctxt);
357 : 4 : const region *src_reg = model->deref_rvalue (src_sval, src_tree, ctxt);
358 : :
359 : 4 : const svalue *data_sval
360 : 4 : = model->read_bytes (src_reg, src_tree, num_bytes_sval, ctxt);
361 : 4 : model->write_bytes (dst_reg, num_bytes_sval, data_sval, ctxt);
362 : 4 : }
363 : : };
364 : :
365 : : /* Handler for:
366 : : type __atomic_load_n (type *ptr, int memorder) */
367 : :
368 : 38388 : class kf_atomic_load_n : public internal_known_function
369 : : {
370 : : public:
371 : : /* This is effectively:
372 : : RET = *PTR;
373 : : return RET;
374 : : */
375 : 41 : void impl_call_pre (const call_details &cd) const final override
376 : : {
377 : 41 : const svalue *ptr_ptr_sval = cd.get_arg_svalue (0);
378 : 41 : tree ptr_ptr_tree = cd.get_arg_tree (0);
379 : : /* Ignore the memorder param. */
380 : :
381 : 41 : region_model *model = cd.get_model ();
382 : 41 : region_model_context *ctxt = cd.get_ctxt ();
383 : :
384 : 41 : const region *ptr_region
385 : 41 : = model->deref_rvalue (ptr_ptr_sval, ptr_ptr_tree, ctxt);
386 : 41 : const svalue *star_ptr_sval = model->get_store_value (ptr_region, ctxt);
387 : 41 : cd.maybe_set_lhs (star_ptr_sval);
388 : 41 : }
389 : : };
390 : :
391 : : /* Handler for:
392 : : void __atomic_store_n (type *ptr, type val, int memorder) */
393 : :
394 : 38388 : class kf_atomic_store_n : public internal_known_function
395 : : {
396 : : public:
397 : : /* This is effectively:
398 : : *PTR = VAL;
399 : : */
400 : 10 : void impl_call_pre (const call_details &cd) const final override
401 : : {
402 : 10 : const svalue *ptr_sval = cd.get_arg_svalue (0);
403 : 10 : tree ptr_tree = cd.get_arg_tree (0);
404 : 10 : const svalue *new_sval = cd.get_arg_svalue (1);
405 : : /* Ignore the memorder param. */
406 : :
407 : 10 : region_model *model = cd.get_model ();
408 : 10 : region_model_context *ctxt = cd.get_ctxt ();
409 : :
410 : 10 : const region *star_ptr_region
411 : 10 : = model->deref_rvalue (ptr_sval, ptr_tree, ctxt);
412 : 10 : model->set_value (star_ptr_region, new_sval, ctxt);
413 : 10 : }
414 : : };
415 : :
416 : : /* Handler for "__builtin_expect" etc. */
417 : :
418 : 9597 : class kf_expect : public internal_known_function
419 : : {
420 : : public:
421 : 59 : void impl_call_pre (const call_details &cd) const final override
422 : : {
423 : : /* __builtin_expect's return value is its initial argument. */
424 : 59 : const svalue *sval = cd.get_arg_svalue (0);
425 : 59 : cd.maybe_set_lhs (sval);
426 : 59 : }
427 : : };
428 : :
429 : : /* Handler for "calloc". */
430 : :
431 : 9597 : class kf_calloc : public builtin_known_function
432 : : {
433 : : public:
434 : 1574 : bool matches_call_types_p (const call_details &cd) const final override
435 : : {
436 : 1574 : return (cd.num_args () == 2
437 : 1574 : && cd.arg_is_size_p (0)
438 : 3148 : && cd.arg_is_size_p (1));
439 : : }
440 : 1368 : enum built_in_function builtin_code () const final override
441 : : {
442 : 1368 : return BUILT_IN_CALLOC;
443 : : }
444 : :
445 : : void impl_call_pre (const call_details &cd) const final override;
446 : : };
447 : :
448 : : void
449 : 445 : kf_calloc::impl_call_pre (const call_details &cd) const
450 : : {
451 : 445 : region_model *model = cd.get_model ();
452 : 445 : region_model_manager *mgr = cd.get_manager ();
453 : 445 : const svalue *nmemb_sval = cd.get_arg_svalue (0);
454 : 445 : const svalue *size_sval = cd.get_arg_svalue (1);
455 : : /* TODO: check for overflow here? */
456 : 445 : const svalue *prod_sval
457 : 445 : = mgr->get_or_create_binop (size_type_node, MULT_EXPR,
458 : : nmemb_sval, size_sval);
459 : 445 : const region *new_reg
460 : 445 : = model->get_or_create_region_for_heap_alloc (prod_sval, cd.get_ctxt ());
461 : 445 : const region *sized_reg
462 : 445 : = mgr->get_sized_region (new_reg, NULL_TREE, prod_sval);
463 : 445 : model->zero_fill_region (sized_reg, cd.get_ctxt ());
464 : 445 : if (cd.get_lhs_type ())
465 : : {
466 : 445 : const svalue *ptr_sval
467 : 445 : = mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
468 : 445 : cd.maybe_set_lhs (ptr_sval);
469 : : }
470 : 445 : }
471 : :
472 : : /* Handler for glibc's "__errno_location". */
473 : :
474 : 12796 : class kf_errno_location : public known_function
475 : : {
476 : : public:
477 : 2742 : bool matches_call_types_p (const call_details &cd) const final override
478 : : {
479 : 2742 : return cd.num_args () == 0;
480 : : }
481 : :
482 : 479 : void impl_call_pre (const call_details &cd) const final override
483 : : {
484 : 479 : if (cd.get_lhs_region ())
485 : : {
486 : 479 : region_model_manager *mgr = cd.get_manager ();
487 : 479 : const region *errno_reg = mgr->get_errno_region ();
488 : 479 : const svalue *errno_ptr = mgr->get_ptr_svalue (cd.get_lhs_type (),
489 : : errno_reg);
490 : 479 : cd.maybe_set_lhs (errno_ptr);
491 : : }
492 : 479 : }
493 : : };
494 : :
495 : : /* Handler for "error" and "error_at_line" from GNU's non-standard <error.h>.
496 : : MIN_ARGS identifies the minimum number of expected arguments
497 : : to be consistent with such a call (3 and 5 respectively). */
498 : :
499 : : class kf_error : public known_function
500 : : {
501 : : public:
502 : 12796 : kf_error (unsigned min_args) : m_min_args (min_args) {}
503 : :
504 : 383 : bool matches_call_types_p (const call_details &cd) const final override
505 : : {
506 : 383 : return (cd.num_args () >= m_min_args
507 : 383 : && cd.get_arg_type (0) == integer_type_node);
508 : : }
509 : :
510 : : void impl_call_pre (const call_details &cd) const final override;
511 : :
512 : : private:
513 : : unsigned m_min_args;
514 : : };
515 : :
516 : : void
517 : 40 : kf_error::impl_call_pre (const call_details &cd) const
518 : : {
519 : : /* The process exits if status != 0, so it only continues
520 : : for the case where status == 0.
521 : : Add that constraint, or terminate this analysis path. */
522 : 40 : tree status = cd.get_arg_tree (0);
523 : 40 : region_model_context *ctxt = cd.get_ctxt ();
524 : 40 : region_model *model = cd.get_model ();
525 : 40 : if (!model->add_constraint (status, EQ_EXPR, integer_zero_node, ctxt))
526 : 15 : if (ctxt)
527 : 15 : ctxt->terminate_path ();
528 : :
529 : : /* Check "format" arg. */
530 : 40 : const int fmt_arg_idx = (m_min_args == 3) ? 2 : 4;
531 : 40 : model->check_for_null_terminated_string_arg (cd, fmt_arg_idx);
532 : 40 : }
533 : :
534 : : /* Handler for fopen.
535 : : FILE *fopen (const char *filename, const char *mode);
536 : : See e.g. https://en.cppreference.com/w/c/io/fopen
537 : : https://www.man7.org/linux/man-pages/man3/fopen.3.html
538 : : https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-wfopen?view=msvc-170 */
539 : :
540 : 3199 : class kf_fopen : public known_function
541 : : {
542 : : public:
543 : 2324 : bool matches_call_types_p (const call_details &cd) const final override
544 : : {
545 : 2324 : return (cd.num_args () == 2
546 : 2324 : && cd.arg_is_pointer_p (0)
547 : 4648 : && cd.arg_is_pointer_p (1));
548 : : }
549 : :
550 : 626 : void impl_call_pre (const call_details &cd) const final override
551 : : {
552 : 626 : cd.check_for_null_terminated_string_arg (0);
553 : 626 : cd.check_for_null_terminated_string_arg (1);
554 : 626 : cd.set_any_lhs_with_defaults ();
555 : :
556 : : /* fopen's mode param is effectively a mini-DSL, but there are various
557 : : non-standard extensions, so we don't bother to check it. */
558 : 626 : }
559 : : };
560 : :
561 : : /* Handler for "free", after sm-handling.
562 : :
563 : : If the ptr points to an underlying heap region, delete the region,
564 : : poisoning pointers to it and regions within it.
565 : :
566 : : We delay this until after sm-state has been updated so that the
567 : : sm-handling can transition all of the various casts of the pointer
568 : : to a "freed" state *before* we delete the related region here.
569 : :
570 : : This has to be done here so that the sm-handling can use the fact
571 : : that they point to the same region to establish that they are equal
572 : : (in region_model::eval_condition), and thus transition
573 : : all pointers to the region to the "freed" state together, regardless
574 : : of casts. */
575 : :
576 : 9597 : class kf_free : public builtin_known_function
577 : : {
578 : : public:
579 : 59991 : bool matches_call_types_p (const call_details &cd) const final override
580 : : {
581 : 59991 : return (cd.num_args () == 1 && cd.arg_is_pointer_p (0));
582 : : }
583 : 69780 : enum built_in_function builtin_code () const final override
584 : : {
585 : 69780 : return BUILT_IN_FREE;
586 : : }
587 : : void impl_call_post (const call_details &cd) const final override;
588 : : };
589 : :
590 : : void
591 : 13061 : kf_free::impl_call_post (const call_details &cd) const
592 : : {
593 : 13061 : const svalue *ptr_sval = cd.get_arg_svalue (0);
594 : 13061 : if (const region *freed_reg = ptr_sval->maybe_get_region ())
595 : : {
596 : : /* If the ptr points to an underlying heap region, delete it,
597 : : poisoning pointers. */
598 : 10370 : region_model *model = cd.get_model ();
599 : 10370 : model->unbind_region_and_descendents (freed_reg, POISON_KIND_FREED);
600 : 10370 : model->unset_dynamic_extents (freed_reg);
601 : : }
602 : 13061 : }
603 : :
604 : : /* Handle the on_call_pre part of "malloc". */
605 : :
606 : 9597 : class kf_malloc : public builtin_known_function
607 : : {
608 : : public:
609 : 40840 : bool matches_call_types_p (const call_details &cd) const final override
610 : : {
611 : 40840 : return (cd.num_args () == 1
612 : 40840 : && cd.arg_is_size_p (0));
613 : : }
614 : 39858 : enum built_in_function builtin_code () const final override
615 : : {
616 : 39858 : return BUILT_IN_MALLOC;
617 : : }
618 : : void impl_call_pre (const call_details &cd) const final override;
619 : : };
620 : :
621 : : void
622 : 10453 : kf_malloc::impl_call_pre (const call_details &cd) const
623 : : {
624 : 10453 : region_model *model = cd.get_model ();
625 : 10453 : region_model_manager *mgr = cd.get_manager ();
626 : 10453 : const svalue *size_sval = cd.get_arg_svalue (0);
627 : 10453 : const region *new_reg
628 : 10453 : = model->get_or_create_region_for_heap_alloc (size_sval, cd.get_ctxt ());
629 : 10453 : if (cd.get_lhs_type ())
630 : : {
631 : 10453 : const svalue *ptr_sval
632 : 10453 : = mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
633 : 10453 : cd.maybe_set_lhs (ptr_sval);
634 : : }
635 : 10453 : }
636 : :
637 : : /* Handler for "memcpy" and "__builtin_memcpy",
638 : : "memmove", and "__builtin_memmove". */
639 : :
640 : : class kf_memcpy_memmove : public builtin_known_function
641 : : {
642 : : public:
643 : : enum kf_memcpy_memmove_variant
644 : : {
645 : : KF_MEMCPY,
646 : : KF_MEMCPY_CHK,
647 : : KF_MEMMOVE,
648 : : KF_MEMMOVE_CHK,
649 : : };
650 : 31990 : kf_memcpy_memmove (enum kf_memcpy_memmove_variant variant)
651 : 31990 : : m_variant (variant) {};
652 : 2468 : bool matches_call_types_p (const call_details &cd) const final override
653 : : {
654 : 2468 : return (cd.num_args () == 3
655 : 2468 : && cd.arg_is_pointer_p (0)
656 : 2468 : && cd.arg_is_pointer_p (1)
657 : 4936 : && cd.arg_is_size_p (2));
658 : : }
659 : 3112 : enum built_in_function builtin_code () const final override
660 : : {
661 : 3112 : switch (m_variant)
662 : : {
663 : : case KF_MEMCPY:
664 : : return BUILT_IN_MEMCPY;
665 : : case KF_MEMCPY_CHK:
666 : : return BUILT_IN_MEMCPY_CHK;
667 : : case KF_MEMMOVE:
668 : : return BUILT_IN_MEMMOVE;
669 : : case KF_MEMMOVE_CHK:
670 : : return BUILT_IN_MEMMOVE_CHK;
671 : 0 : default:
672 : 0 : gcc_unreachable ();
673 : : }
674 : : }
675 : : void impl_call_pre (const call_details &cd) const final override;
676 : : private:
677 : : const enum kf_memcpy_memmove_variant m_variant;
678 : : };
679 : :
680 : : void
681 : 459 : kf_memcpy_memmove::impl_call_pre (const call_details &cd) const
682 : : {
683 : 459 : const svalue *dest_ptr_sval = cd.get_arg_svalue (0);
684 : 459 : const svalue *src_ptr_sval = cd.get_arg_svalue (1);
685 : 459 : const svalue *num_bytes_sval = cd.get_arg_svalue (2);
686 : :
687 : 459 : region_model *model = cd.get_model ();
688 : :
689 : 459 : const region *dest_reg
690 : 459 : = model->deref_rvalue (dest_ptr_sval, cd.get_arg_tree (0), cd.get_ctxt ());
691 : 459 : const region *src_reg
692 : 459 : = model->deref_rvalue (src_ptr_sval, cd.get_arg_tree (1), cd.get_ctxt ());
693 : :
694 : 459 : cd.maybe_set_lhs (dest_ptr_sval);
695 : : /* Check for overlap. */
696 : 459 : switch (m_variant)
697 : : {
698 : 436 : case KF_MEMCPY:
699 : 436 : case KF_MEMCPY_CHK:
700 : 436 : cd.complain_about_overlap (0, 1, num_bytes_sval);
701 : 436 : break;
702 : :
703 : : case KF_MEMMOVE:
704 : : case KF_MEMMOVE_CHK:
705 : : /* It's OK for memmove's arguments to overlap. */
706 : : break;
707 : :
708 : 0 : default:
709 : 0 : gcc_unreachable ();
710 : : }
711 : 459 : model->copy_bytes (dest_reg,
712 : : src_reg, cd.get_arg_tree (1),
713 : : num_bytes_sval,
714 : : cd.get_ctxt ());
715 : 459 : }
716 : :
717 : : /* Handler for "memset" and "__builtin_memset". */
718 : :
719 : : class kf_memset : public builtin_known_function
720 : : {
721 : : public:
722 : 15995 : kf_memset (bool chk_variant) : m_chk_variant (chk_variant) {}
723 : 3166 : bool matches_call_types_p (const call_details &cd) const final override
724 : : {
725 : 3166 : return (cd.num_args () == 3 && cd.arg_is_pointer_p (0));
726 : : }
727 : 3584 : enum built_in_function builtin_code () const final override
728 : : {
729 : 3584 : return m_chk_variant ? BUILT_IN_MEMSET_CHK : BUILT_IN_MEMSET;
730 : : }
731 : : void impl_call_pre (const call_details &cd) const final override;
732 : : private:
733 : : const bool m_chk_variant;
734 : : };
735 : :
736 : : void
737 : 663 : kf_memset::impl_call_pre (const call_details &cd) const
738 : : {
739 : 663 : const svalue *dest_sval = cd.get_arg_svalue (0);
740 : 663 : const svalue *fill_value_sval = cd.get_arg_svalue (1);
741 : 663 : const svalue *num_bytes_sval = cd.get_arg_svalue (2);
742 : :
743 : 663 : region_model *model = cd.get_model ();
744 : 663 : region_model_manager *mgr = cd.get_manager ();
745 : :
746 : 663 : const region *dest_reg
747 : 663 : = model->deref_rvalue (dest_sval, cd.get_arg_tree (0), cd.get_ctxt ());
748 : :
749 : 663 : const svalue *fill_value_u8
750 : 663 : = mgr->get_or_create_cast (unsigned_char_type_node, fill_value_sval);
751 : :
752 : 663 : const region *sized_dest_reg = mgr->get_sized_region (dest_reg,
753 : : NULL_TREE,
754 : : num_bytes_sval);
755 : 663 : model->fill_region (sized_dest_reg, fill_value_u8, cd.get_ctxt ());
756 : :
757 : 663 : cd.maybe_set_lhs (dest_sval);
758 : 663 : }
759 : :
760 : : /* A subclass of pending_diagnostic for complaining about 'putenv'
761 : : called on an auto var. */
762 : :
763 : : class putenv_of_auto_var
764 : : : public pending_diagnostic_subclass<putenv_of_auto_var>
765 : : {
766 : : public:
767 : 7 : putenv_of_auto_var (tree fndecl, const region *reg)
768 : 7 : : m_fndecl (fndecl), m_reg (reg),
769 : 7 : m_var_decl (reg->get_base_region ()->maybe_get_decl ())
770 : : {
771 : 7 : }
772 : :
773 : 36 : const char *get_kind () const final override
774 : : {
775 : 36 : return "putenv_of_auto_var";
776 : : }
777 : :
778 : 7 : bool operator== (const putenv_of_auto_var &other) const
779 : : {
780 : 7 : return (m_fndecl == other.m_fndecl
781 : 7 : && m_reg == other.m_reg
782 : 14 : && same_tree_p (m_var_decl, other.m_var_decl));
783 : : }
784 : :
785 : 14 : int get_controlling_option () const final override
786 : : {
787 : 14 : return OPT_Wanalyzer_putenv_of_auto_var;
788 : : }
789 : :
790 : 7 : bool emit (diagnostic_emission_context &ctxt) final override
791 : : {
792 : 7 : auto_diagnostic_group d;
793 : :
794 : : /* SEI CERT C Coding Standard: "POS34-C. Do not call putenv() with a
795 : : pointer to an automatic variable as the argument". */
796 : 7 : diagnostic_metadata::precanned_rule
797 : 7 : rule ("POS34-C", "https://wiki.sei.cmu.edu/confluence/x/6NYxBQ");
798 : 7 : ctxt.add_rule (rule);
799 : :
800 : 7 : bool warned;
801 : 7 : if (m_var_decl)
802 : 6 : warned = ctxt.warn ("%qE on a pointer to automatic variable %qE",
803 : : m_fndecl, m_var_decl);
804 : : else
805 : 1 : warned = ctxt.warn ("%qE on a pointer to an on-stack buffer",
806 : : m_fndecl);
807 : 7 : if (warned)
808 : : {
809 : 7 : if (m_var_decl)
810 : 6 : inform (DECL_SOURCE_LOCATION (m_var_decl),
811 : : "%qE declared on stack here", m_var_decl);
812 : 7 : inform (ctxt.get_location (), "perhaps use %qs rather than %qE",
813 : : "setenv", m_fndecl);
814 : : }
815 : :
816 : 14 : return warned;
817 : 7 : }
818 : :
819 : : bool
820 : 14 : describe_final_event (pretty_printer &pp,
821 : : const evdesc::final_event &) final override
822 : : {
823 : 14 : if (m_var_decl)
824 : 12 : pp_printf (&pp,
825 : : "%qE on a pointer to automatic variable %qE",
826 : : m_fndecl, m_var_decl);
827 : : else
828 : 2 : pp_printf (&pp,
829 : : "%qE on a pointer to an on-stack buffer",
830 : : m_fndecl);
831 : 14 : return true;
832 : : }
833 : :
834 : 7 : void mark_interesting_stuff (interesting_t *interest) final override
835 : : {
836 : 7 : if (!m_var_decl)
837 : 1 : interest->add_region_creation (m_reg->get_base_region ());
838 : 7 : }
839 : :
840 : : private:
841 : : tree m_fndecl; // non-NULL
842 : : const region *m_reg; // non-NULL
843 : : tree m_var_decl; // could be NULL
844 : : };
845 : :
846 : : /* Handler for calls to "putenv".
847 : :
848 : : In theory we could try to model the state of the environment variables
849 : : for the process; for now we merely complain about putenv of regions
850 : : on the stack. */
851 : :
852 : 3199 : class kf_putenv : public known_function
853 : : {
854 : : public:
855 : 94 : bool matches_call_types_p (const call_details &cd) const final override
856 : : {
857 : 94 : return (cd.num_args () == 1 && cd.arg_is_pointer_p (0));
858 : : }
859 : :
860 : 16 : void impl_call_pre (const call_details &cd) const final override
861 : : {
862 : 16 : tree fndecl = cd.get_fndecl_for_call ();
863 : 16 : gcc_assert (fndecl);
864 : 16 : region_model_context *ctxt = cd.get_ctxt ();
865 : 16 : region_model *model = cd.get_model ();
866 : 16 : model->check_for_null_terminated_string_arg (cd, 0);
867 : 16 : const svalue *ptr_sval = cd.get_arg_svalue (0);
868 : 16 : const region *reg
869 : 16 : = model->deref_rvalue (ptr_sval, cd.get_arg_tree (0), ctxt);
870 : 16 : model->get_store ()->mark_as_escaped (reg);
871 : 16 : enum memory_space mem_space = reg->get_memory_space ();
872 : 16 : switch (mem_space)
873 : : {
874 : 0 : default:
875 : 0 : gcc_unreachable ();
876 : : case MEMSPACE_UNKNOWN:
877 : : case MEMSPACE_CODE:
878 : : case MEMSPACE_GLOBALS:
879 : : case MEMSPACE_HEAP:
880 : : case MEMSPACE_READONLY_DATA:
881 : : break;
882 : 7 : case MEMSPACE_STACK:
883 : 7 : if (ctxt)
884 : 7 : ctxt->warn (make_unique<putenv_of_auto_var> (fndecl, reg));
885 : : break;
886 : : }
887 : 16 : cd.set_any_lhs_with_defaults ();
888 : 16 : }
889 : : };
890 : :
891 : : /* Handler for "realloc":
892 : :
893 : : void *realloc(void *ptr, size_t size);
894 : :
895 : : realloc(3) is awkward, since it has various different outcomes
896 : : that are best modelled as separate exploded nodes/edges.
897 : :
898 : : We first check for sm-state, in
899 : : malloc_state_machine::on_realloc_call, so that we
900 : : can complain about issues such as realloc of a non-heap
901 : : pointer, and terminate the path for such cases (and issue
902 : : the complaints at the call's exploded node).
903 : :
904 : : Assuming that these checks pass, we split the path here into
905 : : three special cases (and terminate the "standard" path):
906 : : (A) failure, returning NULL
907 : : (B) success, growing the buffer in-place without moving it
908 : : (C) success, allocating a new buffer, copying the content
909 : : of the old buffer to it, and freeing the old buffer.
910 : :
911 : : Each of these has a custom_edge_info subclass, which updates
912 : : the region_model and sm-state of the destination state. */
913 : :
914 : 9597 : class kf_realloc : public builtin_known_function
915 : : {
916 : : public:
917 : 2929 : bool matches_call_types_p (const call_details &cd) const final override
918 : : {
919 : 2929 : return (cd.num_args () == 2
920 : 2929 : && cd.arg_is_pointer_p (0)
921 : 5858 : && cd.arg_is_size_p (1));
922 : : }
923 : :
924 : 2766 : enum built_in_function builtin_code () const final override
925 : : {
926 : 2766 : return BUILT_IN_REALLOC;
927 : : }
928 : :
929 : : void impl_call_post (const call_details &cd) const final override;
930 : : };
931 : :
932 : : void
933 : 761 : kf_realloc::impl_call_post (const call_details &cd) const
934 : : {
935 : : /* Three custom subclasses of custom_edge_info, for handling the various
936 : : outcomes of "realloc". */
937 : :
938 : : /* Concrete custom_edge_info: a realloc call that fails, returning NULL. */
939 : 0 : class failure : public failed_call_info
940 : : {
941 : : public:
942 : 437 : failure (const call_details &cd)
943 : 437 : : failed_call_info (cd)
944 : : {
945 : : }
946 : :
947 : 412 : bool update_model (region_model *model,
948 : : const exploded_edge *,
949 : : region_model_context *ctxt) const final override
950 : : {
951 : : /* Return NULL; everything else is unchanged. */
952 : 412 : const call_details cd (get_call_details (model, ctxt));
953 : 412 : region_model_manager *mgr = cd.get_manager ();
954 : 412 : if (cd.get_lhs_type ())
955 : : {
956 : 403 : const svalue *zero
957 : 403 : = mgr->get_or_create_int_cst (cd.get_lhs_type (), 0);
958 : 403 : model->set_value (cd.get_lhs_region (),
959 : : zero,
960 : : cd.get_ctxt ());
961 : : }
962 : 412 : return true;
963 : : }
964 : : };
965 : :
966 : : /* Concrete custom_edge_info: a realloc call that succeeds, growing
967 : : the existing buffer without moving it. */
968 : 0 : class success_no_move : public call_info
969 : : {
970 : : public:
971 : 437 : success_no_move (const call_details &cd)
972 : 437 : : call_info (cd)
973 : : {
974 : : }
975 : :
976 : 8 : void print_desc (pretty_printer &pp) const final override
977 : : {
978 : 8 : pp_printf (&pp,
979 : : "when %qE succeeds, without moving buffer",
980 : : get_fndecl ());
981 : 8 : }
982 : :
983 : 398 : bool update_model (region_model *model,
984 : : const exploded_edge *,
985 : : region_model_context *ctxt) const final override
986 : : {
987 : : /* Update size of buffer and return the ptr unchanged. */
988 : 398 : const call_details cd (get_call_details (model, ctxt));
989 : 398 : region_model_manager *mgr = cd.get_manager ();
990 : 398 : const svalue *ptr_sval = cd.get_arg_svalue (0);
991 : 398 : const svalue *size_sval = cd.get_arg_svalue (1);
992 : :
993 : : /* We can only grow in place with a non-NULL pointer. */
994 : 398 : {
995 : 398 : const svalue *null_ptr
996 : 398 : = mgr->get_or_create_int_cst (ptr_sval->get_type (), 0);
997 : 398 : if (!model->add_constraint (ptr_sval, NE_EXPR, null_ptr,
998 : : cd.get_ctxt ()))
999 : : return false;
1000 : : }
1001 : :
1002 : 392 : if (const region *buffer_reg = model->deref_rvalue (ptr_sval, NULL_TREE,
1003 : : ctxt))
1004 : 392 : if (compat_types_p (size_sval->get_type (), size_type_node))
1005 : 392 : model->set_dynamic_extents (buffer_reg, size_sval, ctxt);
1006 : 392 : if (cd.get_lhs_region ())
1007 : : {
1008 : 383 : model->set_value (cd.get_lhs_region (), ptr_sval, cd.get_ctxt ());
1009 : 383 : const svalue *zero
1010 : 383 : = mgr->get_or_create_int_cst (cd.get_lhs_type (), 0);
1011 : 383 : return model->add_constraint (ptr_sval, NE_EXPR, zero, ctxt);
1012 : : }
1013 : : else
1014 : : return true;
1015 : : }
1016 : : };
1017 : :
1018 : : /* Concrete custom_edge_info: a realloc call that succeeds, freeing
1019 : : the existing buffer and moving the content to a freshly allocated
1020 : : buffer. */
1021 : 0 : class success_with_move : public call_info
1022 : : {
1023 : : public:
1024 : 437 : success_with_move (const call_details &cd)
1025 : 437 : : call_info (cd)
1026 : : {
1027 : : }
1028 : :
1029 : 80 : void print_desc (pretty_printer &pp) const final override
1030 : : {
1031 : 80 : pp_printf (&pp,
1032 : : "when %qE succeeds, moving buffer",
1033 : : get_fndecl ());
1034 : 80 : }
1035 : 438 : bool update_model (region_model *model,
1036 : : const exploded_edge *,
1037 : : region_model_context *ctxt) const final override
1038 : : {
1039 : 438 : const call_details cd (get_call_details (model, ctxt));
1040 : 438 : region_model_manager *mgr = cd.get_manager ();
1041 : 438 : const svalue *old_ptr_sval = cd.get_arg_svalue (0);
1042 : 438 : const svalue *new_size_sval = cd.get_arg_svalue (1);
1043 : :
1044 : : /* Create the new region. */
1045 : 438 : const region *new_reg
1046 : 438 : = model->get_or_create_region_for_heap_alloc (new_size_sval, ctxt);
1047 : 438 : const svalue *new_ptr_sval
1048 : 438 : = mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
1049 : 438 : if (!model->add_constraint (new_ptr_sval, NE_EXPR, old_ptr_sval,
1050 : : cd.get_ctxt ()))
1051 : : return false;
1052 : :
1053 : 438 : if (cd.get_lhs_type ())
1054 : 429 : cd.maybe_set_lhs (new_ptr_sval);
1055 : :
1056 : 438 : if (const region *freed_reg = model->deref_rvalue (old_ptr_sval,
1057 : : NULL_TREE, ctxt))
1058 : : {
1059 : : /* Copy the data. */
1060 : 438 : const svalue *old_size_sval = model->get_dynamic_extents (freed_reg);
1061 : 438 : if (old_size_sval)
1062 : : {
1063 : 175 : const svalue *copied_size_sval
1064 : 175 : = get_copied_size (model, old_size_sval, new_size_sval);
1065 : 175 : const region *copied_old_reg
1066 : 175 : = mgr->get_sized_region (freed_reg, NULL, copied_size_sval);
1067 : 175 : const svalue *buffer_content_sval
1068 : 175 : = model->get_store_value (copied_old_reg, cd.get_ctxt ());
1069 : 175 : const region *copied_new_reg
1070 : 175 : = mgr->get_sized_region (new_reg, NULL, copied_size_sval);
1071 : 175 : model->set_value (copied_new_reg, buffer_content_sval,
1072 : : cd.get_ctxt ());
1073 : : }
1074 : : else
1075 : : {
1076 : : /* We don't know how big the old region was;
1077 : : mark the new region as having been touched to avoid uninit
1078 : : issues. */
1079 : 263 : model->mark_region_as_unknown (new_reg, cd.get_uncertainty ());
1080 : : }
1081 : :
1082 : : /* Free the old region, so that pointers to the old buffer become
1083 : : invalid. */
1084 : :
1085 : : /* If the ptr points to an underlying heap region, delete it,
1086 : : poisoning pointers. */
1087 : 438 : model->unbind_region_and_descendents (freed_reg, POISON_KIND_FREED);
1088 : 438 : model->unset_dynamic_extents (freed_reg);
1089 : : }
1090 : :
1091 : : /* Update the sm-state: mark the old_ptr_sval as "freed",
1092 : : and the new_ptr_sval as "nonnull". */
1093 : 438 : model->on_realloc_with_move (cd, old_ptr_sval, new_ptr_sval);
1094 : :
1095 : 438 : if (cd.get_lhs_type ())
1096 : : {
1097 : 429 : const svalue *zero
1098 : 429 : = mgr->get_or_create_int_cst (cd.get_lhs_type (), 0);
1099 : 429 : return model->add_constraint (new_ptr_sval, NE_EXPR, zero,
1100 : 429 : cd.get_ctxt ());
1101 : : }
1102 : : else
1103 : : return true;
1104 : : }
1105 : :
1106 : : private:
1107 : : /* Return the lesser of OLD_SIZE_SVAL and NEW_SIZE_SVAL.
1108 : : If unknown, OLD_SIZE_SVAL is returned. */
1109 : 175 : const svalue *get_copied_size (region_model *model,
1110 : : const svalue *old_size_sval,
1111 : : const svalue *new_size_sval) const
1112 : : {
1113 : 175 : tristate res
1114 : 175 : = model->eval_condition (old_size_sval, GT_EXPR, new_size_sval);
1115 : 175 : switch (res.get_value ())
1116 : : {
1117 : : case tristate::TS_TRUE:
1118 : : return new_size_sval;
1119 : 143 : case tristate::TS_FALSE:
1120 : 143 : case tristate::TS_UNKNOWN:
1121 : 143 : return old_size_sval;
1122 : 0 : default:
1123 : 0 : gcc_unreachable ();
1124 : : }
1125 : : }
1126 : : };
1127 : :
1128 : : /* Body of kf_realloc::impl_call_post. */
1129 : :
1130 : 761 : if (cd.get_ctxt ())
1131 : : {
1132 : 437 : cd.get_ctxt ()->bifurcate (make_unique<failure> (cd));
1133 : 437 : cd.get_ctxt ()->bifurcate (make_unique<success_no_move> (cd));
1134 : 437 : cd.get_ctxt ()->bifurcate (make_unique<success_with_move> (cd));
1135 : 437 : cd.get_ctxt ()->terminate_path ();
1136 : : }
1137 : 761 : }
1138 : :
1139 : : /* Handler for "strchr" and "__builtin_strchr". */
1140 : :
1141 : 6398 : class kf_strchr : public builtin_known_function
1142 : : {
1143 : : public:
1144 : 223 : bool matches_call_types_p (const call_details &cd) const final override
1145 : : {
1146 : 223 : return (cd.num_args () == 2 && cd.arg_is_pointer_p (0));
1147 : : }
1148 : 58 : void impl_call_pre (const call_details &cd) const final override
1149 : : {
1150 : 58 : cd.check_for_null_terminated_string_arg (0);
1151 : 58 : }
1152 : :
1153 : 216 : enum built_in_function builtin_code () const final override
1154 : : {
1155 : 216 : return BUILT_IN_STRCHR;
1156 : : }
1157 : : void impl_call_post (const call_details &cd) const final override;
1158 : : };
1159 : :
1160 : : void
1161 : 57 : kf_strchr::impl_call_post (const call_details &cd) const
1162 : : {
1163 : 0 : class strchr_call_info : public call_info
1164 : : {
1165 : : public:
1166 : 52 : strchr_call_info (const call_details &cd, bool found)
1167 : 52 : : call_info (cd), m_found (found)
1168 : : {
1169 : : }
1170 : :
1171 : 38 : void print_desc (pretty_printer &pp) const final override
1172 : : {
1173 : 38 : if (m_found)
1174 : 18 : pp_printf (&pp,
1175 : : "when %qE returns non-NULL",
1176 : : get_fndecl ());
1177 : : else
1178 : 20 : pp_printf (&pp,
1179 : : "when %qE returns NULL",
1180 : : get_fndecl ());
1181 : 38 : }
1182 : :
1183 : 81 : bool update_model (region_model *model,
1184 : : const exploded_edge *,
1185 : : region_model_context *ctxt) const final override
1186 : : {
1187 : 81 : const call_details cd (get_call_details (model, ctxt));
1188 : 81 : if (tree lhs_type = cd.get_lhs_type ())
1189 : : {
1190 : 79 : region_model_manager *mgr = model->get_manager ();
1191 : 79 : const svalue *result;
1192 : 79 : if (m_found)
1193 : : {
1194 : 39 : const svalue *str_sval = cd.get_arg_svalue (0);
1195 : 39 : const region *str_reg
1196 : 39 : = model->deref_rvalue (str_sval, cd.get_arg_tree (0),
1197 : : cd.get_ctxt ());
1198 : : /* We want str_sval + OFFSET for some unknown OFFSET.
1199 : : Use a conjured_svalue to represent the offset,
1200 : : using the str_reg as the id of the conjured_svalue. */
1201 : 39 : const svalue *offset
1202 : 39 : = mgr->get_or_create_conjured_svalue (size_type_node,
1203 : 39 : cd.get_call_stmt (),
1204 : : str_reg,
1205 : 39 : conjured_purge (model,
1206 : 39 : ctxt));
1207 : 39 : result = mgr->get_or_create_binop (lhs_type, POINTER_PLUS_EXPR,
1208 : : str_sval, offset);
1209 : : }
1210 : : else
1211 : 40 : result = mgr->get_or_create_int_cst (lhs_type, 0);
1212 : 79 : cd.maybe_set_lhs (result);
1213 : : }
1214 : 81 : return true;
1215 : : }
1216 : : private:
1217 : : bool m_found;
1218 : : };
1219 : :
1220 : : /* Body of kf_strchr::impl_call_post. */
1221 : 57 : if (cd.get_ctxt ())
1222 : : {
1223 : 26 : cd.get_ctxt ()->bifurcate (make_unique<strchr_call_info> (cd, false));
1224 : 26 : cd.get_ctxt ()->bifurcate (make_unique<strchr_call_info> (cd, true));
1225 : 26 : cd.get_ctxt ()->terminate_path ();
1226 : : }
1227 : 57 : }
1228 : :
1229 : : /* Handler for "sprintf".
1230 : : int sprintf(char *str, const char *format, ...);
1231 : : */
1232 : :
1233 : 6398 : class kf_sprintf : public builtin_known_function
1234 : : {
1235 : : public:
1236 : 3359 : bool matches_call_types_p (const call_details &cd) const final override
1237 : : {
1238 : 3359 : return (cd.num_args () >= 2
1239 : 3359 : && cd.arg_is_pointer_p (0)
1240 : 6718 : && cd.arg_is_pointer_p (1));
1241 : : }
1242 : :
1243 : 408 : enum built_in_function builtin_code () const final override
1244 : : {
1245 : 408 : return BUILT_IN_SPRINTF;
1246 : : }
1247 : :
1248 : 1586 : void impl_call_pre (const call_details &cd) const final override
1249 : : {
1250 : : /* For now, merely assume that the destination buffer gets set to a
1251 : : new svalue. */
1252 : 1586 : region_model *model = cd.get_model ();
1253 : 1586 : region_model_context *ctxt = cd.get_ctxt ();
1254 : 1586 : const svalue *dst_ptr = cd.get_arg_svalue (0);
1255 : 1586 : const region *dst_reg
1256 : 1586 : = model->deref_rvalue (dst_ptr, cd.get_arg_tree (0), ctxt);
1257 : 1586 : const svalue *content = cd.get_or_create_conjured_svalue (dst_reg);
1258 : 1586 : model->set_value (dst_reg, content, ctxt);
1259 : 1586 : cd.set_any_lhs_with_defaults ();
1260 : 1586 : }
1261 : : };
1262 : :
1263 : : /* Handler for "__builtin_stack_restore". */
1264 : :
1265 : 3199 : class kf_stack_restore : public pure_known_function_with_default_return
1266 : : {
1267 : : public:
1268 : 0 : bool matches_call_types_p (const call_details &) const final override
1269 : : {
1270 : 0 : return true;
1271 : : }
1272 : :
1273 : : /* Currently a no-op. */
1274 : : };
1275 : :
1276 : : /* Handler for "__builtin_stack_save". */
1277 : :
1278 : 3199 : class kf_stack_save : public pure_known_function_with_default_return
1279 : : {
1280 : : public:
1281 : 0 : bool matches_call_types_p (const call_details &) const final override
1282 : : {
1283 : 0 : return true;
1284 : : }
1285 : :
1286 : : /* Currently a no-op. */
1287 : : };
1288 : :
1289 : : /* Handler for "strcat" and "__builtin_strcat_chk". */
1290 : :
1291 : : class kf_strcat : public builtin_known_function
1292 : : {
1293 : : public:
1294 : 15995 : kf_strcat (unsigned int num_args, bool chk_variant)
1295 : 15995 : : m_num_args (num_args),
1296 : 15995 : m_chk_variant (chk_variant) {}
1297 : 345 : bool matches_call_types_p (const call_details &cd) const final override
1298 : : {
1299 : 345 : return (cd.num_args () == m_num_args
1300 : 345 : && cd.arg_is_pointer_p (0)
1301 : 690 : && cd.arg_is_pointer_p (1));
1302 : : }
1303 : :
1304 : 472 : enum built_in_function builtin_code () const final override
1305 : : {
1306 : 472 : return m_chk_variant ? BUILT_IN_STRCAT_CHK : BUILT_IN_STRCAT;
1307 : : }
1308 : :
1309 : 59 : void impl_call_pre (const call_details &cd) const final override
1310 : : {
1311 : 59 : region_model *model = cd.get_model ();
1312 : 59 : region_model_manager *mgr = cd.get_manager ();
1313 : :
1314 : 59 : const svalue *dest_sval = cd.get_arg_svalue (0);
1315 : 59 : const region *dest_reg = model->deref_rvalue (dest_sval, cd.get_arg_tree (0),
1316 : : cd.get_ctxt ());
1317 : :
1318 : 59 : const svalue *dst_strlen_sval
1319 : 59 : = cd.check_for_null_terminated_string_arg (0, false, nullptr);
1320 : 59 : if (!dst_strlen_sval)
1321 : : {
1322 : 5 : if (cd.get_ctxt ())
1323 : 5 : cd.get_ctxt ()->terminate_path ();
1324 : 7 : return;
1325 : : }
1326 : :
1327 : 54 : const svalue *bytes_to_copy;
1328 : 54 : const svalue *num_src_bytes_read_sval
1329 : 54 : = cd.check_for_null_terminated_string_arg (1, true, &bytes_to_copy);
1330 : 54 : if (!num_src_bytes_read_sval)
1331 : : {
1332 : 2 : if (cd.get_ctxt ())
1333 : 2 : cd.get_ctxt ()->terminate_path ();
1334 : 2 : return;
1335 : : }
1336 : :
1337 : 52 : cd.maybe_set_lhs (dest_sval);
1338 : 52 : cd.complain_about_overlap (0, 1, num_src_bytes_read_sval);
1339 : :
1340 : 52 : const region *offset_reg
1341 : 52 : = mgr->get_offset_region (dest_reg, NULL_TREE, dst_strlen_sval);
1342 : 52 : model->write_bytes (offset_reg,
1343 : : num_src_bytes_read_sval,
1344 : : bytes_to_copy,
1345 : : cd.get_ctxt ());
1346 : : }
1347 : :
1348 : : private:
1349 : : unsigned int m_num_args;
1350 : : const bool m_chk_variant;
1351 : : };
1352 : :
1353 : : /* Handler for "strcpy" and "__builtin_strcpy_chk". */
1354 : :
1355 : : class kf_strcpy : public builtin_known_function
1356 : : {
1357 : : public:
1358 : 15995 : kf_strcpy (unsigned int num_args, bool chk_variant)
1359 : 15995 : : m_num_args (num_args),
1360 : 15995 : m_chk_variant (chk_variant) {}
1361 : 1432 : bool matches_call_types_p (const call_details &cd) const final override
1362 : : {
1363 : 1432 : return (cd.num_args () == m_num_args
1364 : 1432 : && cd.arg_is_pointer_p (0)
1365 : 2864 : && cd.arg_is_pointer_p (1));
1366 : : }
1367 : 776 : enum built_in_function builtin_code () const final override
1368 : : {
1369 : 776 : return m_chk_variant ? BUILT_IN_STRCPY_CHK : BUILT_IN_STRCPY;
1370 : : }
1371 : : void impl_call_pre (const call_details &cd) const final override;
1372 : :
1373 : : private:
1374 : : unsigned int m_num_args;
1375 : : const bool m_chk_variant;
1376 : : };
1377 : :
1378 : : void
1379 : 523 : kf_strcpy::impl_call_pre (const call_details &cd) const
1380 : : {
1381 : 523 : region_model *model = cd.get_model ();
1382 : 523 : region_model_context *ctxt = cd.get_ctxt ();
1383 : :
1384 : 523 : const svalue *dest_sval = cd.get_arg_svalue (0);
1385 : 523 : const region *dest_reg = model->deref_rvalue (dest_sval, cd.get_arg_tree (0),
1386 : : ctxt);
1387 : : /* strcpy returns the initial param. */
1388 : 523 : cd.maybe_set_lhs (dest_sval);
1389 : :
1390 : 523 : const svalue *bytes_to_copy;
1391 : 1046 : if (const svalue *num_bytes_read_sval
1392 : 523 : = cd.check_for_null_terminated_string_arg (1, true, &bytes_to_copy))
1393 : : {
1394 : 521 : cd.complain_about_overlap (0, 1, num_bytes_read_sval);
1395 : 521 : model->write_bytes (dest_reg, num_bytes_read_sval, bytes_to_copy, ctxt);
1396 : : }
1397 : : else
1398 : : {
1399 : 2 : if (cd.get_ctxt ())
1400 : 2 : cd.get_ctxt ()->terminate_path ();
1401 : : }
1402 : 523 : }
1403 : :
1404 : : /* Handler for "strdup" and "__builtin_strdup". */
1405 : :
1406 : 6398 : class kf_strdup : public builtin_known_function
1407 : : {
1408 : : public:
1409 : 1447 : bool matches_call_types_p (const call_details &cd) const final override
1410 : : {
1411 : 1447 : return (cd.num_args () == 1 && cd.arg_is_pointer_p (0));
1412 : : }
1413 : 1590 : enum built_in_function builtin_code () const final override
1414 : : {
1415 : 1590 : return BUILT_IN_STRDUP;
1416 : : }
1417 : 327 : void impl_call_pre (const call_details &cd) const final override
1418 : : {
1419 : 327 : region_model *model = cd.get_model ();
1420 : 327 : region_model_context *ctxt = cd.get_ctxt ();
1421 : 327 : region_model_manager *mgr = cd.get_manager ();
1422 : 327 : const svalue *bytes_to_copy;
1423 : 654 : if (const svalue *num_bytes_read_sval
1424 : 327 : = cd.check_for_null_terminated_string_arg (0, true, &bytes_to_copy))
1425 : : {
1426 : 325 : const region *new_reg
1427 : 325 : = model->get_or_create_region_for_heap_alloc (num_bytes_read_sval,
1428 : : ctxt);
1429 : 325 : model->write_bytes (new_reg, num_bytes_read_sval, bytes_to_copy, ctxt);
1430 : 325 : if (cd.get_lhs_type ())
1431 : : {
1432 : 325 : const svalue *ptr_sval
1433 : 325 : = mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
1434 : 325 : cd.maybe_set_lhs (ptr_sval);
1435 : : }
1436 : : }
1437 : : else
1438 : : {
1439 : 2 : if (ctxt)
1440 : 2 : ctxt->terminate_path ();
1441 : : }
1442 : 327 : }
1443 : : };
1444 : :
1445 : : /* Handler for "strlen" and for "__analyzer_get_strlen". */
1446 : :
1447 : 12796 : class kf_strlen : public builtin_known_function
1448 : : {
1449 : : public:
1450 : 8214 : bool matches_call_types_p (const call_details &cd) const final override
1451 : : {
1452 : 8214 : return (cd.num_args () == 1 && cd.arg_is_pointer_p (0));
1453 : : }
1454 : 5680 : enum built_in_function builtin_code () const final override
1455 : : {
1456 : 5680 : return BUILT_IN_STRLEN;
1457 : : }
1458 : :
1459 : 2695 : void impl_call_pre (const call_details &cd) const final override
1460 : : {
1461 : 5390 : if (const svalue *strlen_sval
1462 : 2695 : = cd.check_for_null_terminated_string_arg (0, false, nullptr))
1463 : 2678 : if (strlen_sval->get_kind () != SK_UNKNOWN)
1464 : : {
1465 : 2144 : cd.maybe_set_lhs (strlen_sval);
1466 : 2144 : return;
1467 : : }
1468 : :
1469 : : /* Use a conjured svalue. */
1470 : 551 : cd.set_any_lhs_with_defaults ();
1471 : : }
1472 : : };
1473 : :
1474 : : /* Factory function, so that kf-analyzer.cc can use this class. */
1475 : :
1476 : : std::unique_ptr<known_function>
1477 : 3199 : make_kf_strlen ()
1478 : : {
1479 : 3199 : return make_unique<kf_strlen> ();
1480 : : }
1481 : :
1482 : : /* Handler for "strncpy" and "__builtin_strncpy".
1483 : : See e.g. https://en.cppreference.com/w/c/string/byte/strncpy
1484 : :
1485 : : extern char *strncpy (char *dst, const char *src, size_t count);
1486 : :
1487 : : Handle this by splitting into two outcomes:
1488 : : (a) truncated read from "src" of "count" bytes,
1489 : : writing "count" bytes to "dst"
1490 : : (b) read from "src" of up to (and including) the null terminator,
1491 : : where the number of bytes read < "count" bytes,
1492 : : writing those bytes to "dst", and zero-filling the rest,
1493 : : up to "count". */
1494 : :
1495 : 9597 : class kf_strncpy : public builtin_known_function
1496 : : {
1497 : : public:
1498 : 1978 : bool matches_call_types_p (const call_details &cd) const final override
1499 : : {
1500 : 1978 : return (cd.num_args () == 3
1501 : 1978 : && cd.arg_is_pointer_p (0)
1502 : 1978 : && cd.arg_is_pointer_p (1)
1503 : 3956 : && cd.arg_is_integral_p (2));
1504 : : }
1505 : 2296 : enum built_in_function builtin_code () const final override
1506 : : {
1507 : 2296 : return BUILT_IN_STRNCPY;
1508 : : }
1509 : : void impl_call_post (const call_details &cd) const final override;
1510 : : };
1511 : :
1512 : : void
1513 : 411 : kf_strncpy::impl_call_post (const call_details &cd) const
1514 : : {
1515 : 0 : class strncpy_call_info : public call_info
1516 : : {
1517 : : public:
1518 : 558 : strncpy_call_info (const call_details &cd,
1519 : : const svalue *num_bytes_with_terminator_sval,
1520 : : bool truncated_read)
1521 : 558 : : call_info (cd),
1522 : 558 : m_num_bytes_with_terminator_sval (num_bytes_with_terminator_sval),
1523 : 558 : m_truncated_read (truncated_read)
1524 : : {
1525 : : }
1526 : :
1527 : 72 : void print_desc (pretty_printer &pp) const final override
1528 : : {
1529 : 72 : if (m_truncated_read)
1530 : 0 : pp_printf (&pp,
1531 : : "when %qE truncates the source string",
1532 : : get_fndecl ());
1533 : : else
1534 : 72 : pp_printf (&pp,
1535 : : "when %qE copies the full source string",
1536 : : get_fndecl ());
1537 : 72 : }
1538 : :
1539 : 466 : bool update_model (region_model *model,
1540 : : const exploded_edge *,
1541 : : region_model_context *ctxt) const final override
1542 : : {
1543 : 466 : const call_details cd (get_call_details (model, ctxt));
1544 : :
1545 : 466 : const svalue *dest_sval = cd.get_arg_svalue (0);
1546 : 466 : const region *dest_reg
1547 : 466 : = model->deref_rvalue (dest_sval, cd.get_arg_tree (0), ctxt);
1548 : :
1549 : 466 : const svalue *src_sval = cd.get_arg_svalue (1);
1550 : 466 : const region *src_reg
1551 : 466 : = model->deref_rvalue (src_sval, cd.get_arg_tree (1), ctxt);
1552 : :
1553 : 466 : const svalue *count_sval = cd.get_arg_svalue (2);
1554 : :
1555 : : /* strncpy returns the initial param. */
1556 : 466 : cd.maybe_set_lhs (dest_sval);
1557 : :
1558 : 466 : const svalue *num_bytes_read_sval;
1559 : 466 : if (m_truncated_read)
1560 : : {
1561 : : /* Truncated read. */
1562 : 233 : num_bytes_read_sval = count_sval;
1563 : :
1564 : 233 : if (m_num_bytes_with_terminator_sval)
1565 : : {
1566 : : /* The terminator is after the limit. */
1567 : 203 : if (!model->add_constraint (m_num_bytes_with_terminator_sval,
1568 : : GT_EXPR,
1569 : : count_sval,
1570 : : ctxt))
1571 : : return false;
1572 : : }
1573 : : else
1574 : : {
1575 : : /* We don't know where the terminator is, or if there is one.
1576 : : In theory we know that the first COUNT bytes are non-zero,
1577 : : but we don't have a way to record that constraint. */
1578 : : }
1579 : : }
1580 : : else
1581 : : {
1582 : : /* Full read of the src string before reaching the limit,
1583 : : so there must be a terminator and it must be at or before
1584 : : the limit. */
1585 : 233 : if (m_num_bytes_with_terminator_sval)
1586 : : {
1587 : 203 : if (!model->add_constraint (m_num_bytes_with_terminator_sval,
1588 : : LE_EXPR,
1589 : : count_sval,
1590 : : ctxt))
1591 : : return false;
1592 : 199 : num_bytes_read_sval = m_num_bytes_with_terminator_sval;
1593 : :
1594 : : /* First, zero-fill the dest buffer.
1595 : : We don't need to do this for the truncation case, as
1596 : : this fully populates the dest buffer. */
1597 : 199 : const region *sized_dest_reg
1598 : 199 : = model->get_manager ()->get_sized_region (dest_reg,
1599 : : NULL_TREE,
1600 : : count_sval);
1601 : 199 : model->zero_fill_region (sized_dest_reg, ctxt);
1602 : : }
1603 : : else
1604 : : {
1605 : : /* Don't analyze this case; the other case will
1606 : : assume a "truncated" read up to the limit. */
1607 : : return false;
1608 : : }
1609 : : }
1610 : :
1611 : 418 : gcc_assert (num_bytes_read_sval);
1612 : :
1613 : 418 : const svalue *bytes_to_copy
1614 : 418 : = model->read_bytes (src_reg,
1615 : : cd.get_arg_tree (1),
1616 : : num_bytes_read_sval,
1617 : : ctxt);
1618 : 418 : cd.complain_about_overlap (0, 1, num_bytes_read_sval);
1619 : 418 : model->write_bytes (dest_reg,
1620 : : num_bytes_read_sval,
1621 : : bytes_to_copy,
1622 : : ctxt);
1623 : :
1624 : 418 : return true;
1625 : : }
1626 : : private:
1627 : : /* (strlen + 1) of the source string if it has a terminator,
1628 : : or NULL for the case where UB would happen before
1629 : : finding any terminator. */
1630 : : const svalue *m_num_bytes_with_terminator_sval;
1631 : :
1632 : : /* true: if this is the outcome where the limit was reached before
1633 : : the null terminator
1634 : : false: if the null terminator was reached before the limit. */
1635 : : bool m_truncated_read;
1636 : : };
1637 : :
1638 : : /* Body of kf_strncpy::impl_call_post. */
1639 : 411 : if (cd.get_ctxt ())
1640 : : {
1641 : : /* First, scan for a null terminator as if there were no limit,
1642 : : with a null ctxt so no errors are reported. */
1643 : 279 : const region_model *model = cd.get_model ();
1644 : 279 : const svalue *ptr_arg_sval = cd.get_arg_svalue (1);
1645 : 279 : const region *buf_reg
1646 : 279 : = model->deref_rvalue (ptr_arg_sval, cd.get_arg_tree (1), nullptr);
1647 : 279 : const svalue *num_bytes_with_terminator_sval
1648 : 279 : = model->scan_for_null_terminator (buf_reg,
1649 : : cd.get_arg_tree (1),
1650 : : nullptr,
1651 : 279 : nullptr);
1652 : 279 : cd.get_ctxt ()->bifurcate
1653 : 279 : (make_unique<strncpy_call_info> (cd, num_bytes_with_terminator_sval,
1654 : 279 : false));
1655 : 279 : cd.get_ctxt ()->bifurcate
1656 : 279 : (make_unique<strncpy_call_info> (cd, num_bytes_with_terminator_sval,
1657 : 279 : true));
1658 : 279 : cd.get_ctxt ()->terminate_path ();
1659 : : }
1660 : 411 : };
1661 : :
1662 : : /* Handler for "strndup" and "__builtin_strndup". */
1663 : :
1664 : 6398 : class kf_strndup : public builtin_known_function
1665 : : {
1666 : : public:
1667 : 94 : bool matches_call_types_p (const call_details &cd) const final override
1668 : : {
1669 : 94 : return (cd.num_args () == 2 && cd.arg_is_pointer_p (0));
1670 : : }
1671 : 84 : enum built_in_function builtin_code () const final override
1672 : : {
1673 : 84 : return BUILT_IN_STRNDUP;
1674 : : }
1675 : 26 : void impl_call_pre (const call_details &cd) const final override
1676 : : {
1677 : 26 : region_model *model = cd.get_model ();
1678 : 26 : region_model_manager *mgr = cd.get_manager ();
1679 : : /* Ideally we'd get the size here, and simulate copying the bytes. */
1680 : 26 : const region *new_reg
1681 : 26 : = model->get_or_create_region_for_heap_alloc (NULL, cd.get_ctxt ());
1682 : 26 : model->mark_region_as_unknown (new_reg, NULL);
1683 : 26 : if (cd.get_lhs_type ())
1684 : : {
1685 : 26 : const svalue *ptr_sval
1686 : 26 : = mgr->get_ptr_svalue (cd.get_lhs_type (), new_reg);
1687 : 26 : cd.maybe_set_lhs (ptr_sval);
1688 : : }
1689 : 26 : }
1690 : : };
1691 : :
1692 : : /* Handler for "strstr" and "__builtin_strstr".
1693 : : extern char *strstr (const char* str, const char* substr);
1694 : : See e.g. https://en.cppreference.com/w/c/string/byte/strstr */
1695 : :
1696 : 6398 : class kf_strstr : public builtin_known_function
1697 : : {
1698 : : public:
1699 : 430 : bool matches_call_types_p (const call_details &cd) const final override
1700 : : {
1701 : 430 : return (cd.num_args () == 2
1702 : 430 : && cd.arg_is_pointer_p (0)
1703 : 860 : && cd.arg_is_pointer_p (1));
1704 : : }
1705 : 488 : enum built_in_function builtin_code () const final override
1706 : : {
1707 : 488 : return BUILT_IN_STRSTR;
1708 : : }
1709 : 101 : void impl_call_pre (const call_details &cd) const final override
1710 : : {
1711 : 101 : cd.check_for_null_terminated_string_arg (0);
1712 : 101 : cd.check_for_null_terminated_string_arg (1);
1713 : 101 : }
1714 : : void impl_call_post (const call_details &cd) const final override;
1715 : : };
1716 : :
1717 : : void
1718 : 85 : kf_strstr::impl_call_post (const call_details &cd) const
1719 : : {
1720 : 0 : class strstr_call_info : public call_info
1721 : : {
1722 : : public:
1723 : 90 : strstr_call_info (const call_details &cd, bool found)
1724 : 90 : : call_info (cd), m_found (found)
1725 : : {
1726 : : }
1727 : :
1728 : 8 : void print_desc (pretty_printer &pp) const final override
1729 : : {
1730 : 8 : if (m_found)
1731 : 0 : pp_printf (&pp,
1732 : : "when %qE returns non-NULL",
1733 : : get_fndecl ());
1734 : : else
1735 : 8 : pp_printf (&pp,
1736 : : "when %qE returns NULL",
1737 : : get_fndecl ());
1738 : 8 : }
1739 : :
1740 : 90 : bool update_model (region_model *model,
1741 : : const exploded_edge *,
1742 : : region_model_context *ctxt) const final override
1743 : : {
1744 : 90 : const call_details cd (get_call_details (model, ctxt));
1745 : 90 : if (tree lhs_type = cd.get_lhs_type ())
1746 : : {
1747 : 90 : region_model_manager *mgr = model->get_manager ();
1748 : 90 : const svalue *result;
1749 : 90 : if (m_found)
1750 : : {
1751 : 25 : const svalue *str_sval = cd.get_arg_svalue (0);
1752 : 25 : const region *str_reg
1753 : 25 : = model->deref_rvalue (str_sval, cd.get_arg_tree (0),
1754 : : cd.get_ctxt ());
1755 : : /* We want str_sval + OFFSET for some unknown OFFSET.
1756 : : Use a conjured_svalue to represent the offset,
1757 : : using the str_reg as the id of the conjured_svalue. */
1758 : 25 : const svalue *offset
1759 : 25 : = mgr->get_or_create_conjured_svalue (size_type_node,
1760 : 25 : cd.get_call_stmt (),
1761 : : str_reg,
1762 : 25 : conjured_purge (model,
1763 : 25 : ctxt));
1764 : 25 : result = mgr->get_or_create_binop (lhs_type, POINTER_PLUS_EXPR,
1765 : : str_sval, offset);
1766 : : }
1767 : : else
1768 : 65 : result = mgr->get_or_create_int_cst (lhs_type, 0);
1769 : 90 : cd.maybe_set_lhs (result);
1770 : : }
1771 : 90 : return true;
1772 : : }
1773 : : private:
1774 : : bool m_found;
1775 : : };
1776 : :
1777 : : /* Body of kf_strstr::impl_call_post. */
1778 : 85 : if (cd.get_ctxt ())
1779 : : {
1780 : 45 : cd.get_ctxt ()->bifurcate (make_unique<strstr_call_info> (cd, false));
1781 : 45 : cd.get_ctxt ()->bifurcate (make_unique<strstr_call_info> (cd, true));
1782 : 45 : cd.get_ctxt ()->terminate_path ();
1783 : : }
1784 : 85 : }
1785 : :
1786 : : /* Handle calls to "strtok".
1787 : : See e.g.
1788 : : https://en.cppreference.com/w/c/string/byte/strtok
1789 : : https://man7.org/linux/man-pages/man3/strtok.3.html */
1790 : :
1791 : : class kf_strtok : public known_function
1792 : : {
1793 : : public:
1794 : : class undefined_behavior : public undefined_function_behavior
1795 : : {
1796 : : public:
1797 : 8 : undefined_behavior (const call_details &cd)
1798 : 8 : : undefined_function_behavior (cd)
1799 : : {
1800 : : }
1801 : 12 : int get_controlling_option () const final override
1802 : : {
1803 : 12 : return OPT_Wanalyzer_undefined_behavior_strtok;
1804 : : }
1805 : :
1806 : 4 : bool emit (diagnostic_emission_context &ctxt) final override
1807 : : {
1808 : : /* CWE-476: NULL Pointer Dereference. */
1809 : 4 : ctxt.add_cwe (476);
1810 : 4 : if (ctxt.warn ("calling %qD for first time with NULL as argument 1"
1811 : : " has undefined behavior",
1812 : : get_callee_fndecl ()))
1813 : : {
1814 : 4 : inform (ctxt.get_location (),
1815 : : "some implementations of %qD may crash on such input",
1816 : : get_callee_fndecl ());
1817 : 4 : return true;
1818 : : }
1819 : : return false;
1820 : : }
1821 : :
1822 : : bool
1823 : 8 : describe_final_event (pretty_printer &pp,
1824 : : const evdesc::final_event &) final override
1825 : : {
1826 : 8 : pp_printf (&pp,
1827 : : "calling %qD for first time with NULL as argument 1"
1828 : : " has undefined behavior",
1829 : : get_callee_fndecl ());
1830 : 8 : return true;
1831 : : }
1832 : : };
1833 : :
1834 : : /* An outcome of a "strtok" call.
1835 : : We have a four-way bifurcation of the analysis via the
1836 : : 4 combinations of two flags:
1837 : : - m_nonnull_str covers whether the "str" param was null or non-null
1838 : : - m_found covers whether the result is null or non-null
1839 : : */
1840 : : class strtok_call_info : public call_info
1841 : : {
1842 : : public:
1843 : 760 : strtok_call_info (const call_details &cd,
1844 : : const private_region &private_reg,
1845 : : bool nonnull_str,
1846 : : bool found)
1847 : 760 : : call_info (cd),
1848 : 760 : m_private_reg (private_reg),
1849 : 760 : m_nonnull_str (nonnull_str),
1850 : 760 : m_found (found)
1851 : : {
1852 : : }
1853 : :
1854 : 0 : void print_desc (pretty_printer &pp) const final override
1855 : : {
1856 : 0 : if (m_nonnull_str)
1857 : : {
1858 : 0 : if (m_found)
1859 : 0 : pp_printf (&pp,
1860 : : "when %qE on non-NULL string returns non-NULL",
1861 : : get_fndecl ());
1862 : : else
1863 : 0 : pp_printf (&pp,
1864 : : "when %qE on non-NULL string returns NULL",
1865 : : get_fndecl ());
1866 : : }
1867 : : else
1868 : : {
1869 : 0 : if (m_found)
1870 : 0 : pp_printf (&pp,
1871 : : "when %qE with NULL string (using prior) returns"
1872 : : " non-NULL",
1873 : : get_fndecl ());
1874 : : else
1875 : 0 : pp_printf (&pp,
1876 : : "when %qE with NULL string (using prior) returns NULL",
1877 : : get_fndecl ());
1878 : : }
1879 : 0 : }
1880 : :
1881 : 500 : bool update_model (region_model *model,
1882 : : const exploded_edge *,
1883 : : region_model_context *ctxt) const final override
1884 : : {
1885 : 500 : region_model_manager *mgr = model->get_manager ();
1886 : 500 : const call_details cd (get_call_details (model, ctxt));
1887 : 500 : const svalue *str_sval = cd.get_arg_svalue (0);
1888 : : /* const svalue *delim_sval = cd.get_arg_svalue (1); */
1889 : :
1890 : 500 : cd.check_for_null_terminated_string_arg (1);
1891 : : /* We check that either arg 0 or the private region is null
1892 : : terminated below. */
1893 : :
1894 : 500 : const svalue *null_ptr_sval
1895 : 500 : = mgr->get_or_create_null_ptr (cd.get_arg_type (0));;
1896 : 752 : if (!model->add_constraint (str_sval,
1897 : 500 : m_nonnull_str ? NE_EXPR : EQ_EXPR,
1898 : : null_ptr_sval,
1899 : : cd.get_ctxt ()))
1900 : : return false;
1901 : :
1902 : 284 : if (m_nonnull_str)
1903 : : {
1904 : : /* Update internal buffer. */
1905 : 64 : model->set_value (&m_private_reg,
1906 : : mgr->get_or_create_unmergeable (str_sval),
1907 : : ctxt);
1908 : : }
1909 : : else
1910 : : {
1911 : : /* Read from internal buffer. */
1912 : 220 : str_sval = model->get_store_value (&m_private_reg, ctxt);
1913 : :
1914 : : /* The initial value of the private region is NULL when we're
1915 : : on a path from main. */
1916 : 440 : if (const initial_svalue *initial_sval
1917 : 220 : = str_sval->dyn_cast_initial_svalue ())
1918 : 48 : if (initial_sval->get_region () == &m_private_reg
1919 : 48 : && model->called_from_main_p ())
1920 : : {
1921 : : /* Implementations of strtok do not necessarily check for NULL
1922 : : here, and may crash; see PR analyzer/107573.
1923 : : Warn for this, if we were definitely passed NULL. */
1924 : 16 : if (cd.get_arg_svalue (0)->all_zeroes_p ())
1925 : : {
1926 : 8 : if (ctxt)
1927 : 8 : ctxt->warn (::make_unique<undefined_behavior> (cd));
1928 : : }
1929 : :
1930 : : /* Assume that "str" was actually non-null; terminate
1931 : : this path. */
1932 : 16 : return false;
1933 : : }
1934 : :
1935 : : /* Now assume str_sval is non-null. */
1936 : 204 : if (!model->add_constraint (str_sval,
1937 : : NE_EXPR,
1938 : : null_ptr_sval,
1939 : : cd.get_ctxt ()))
1940 : : return false;
1941 : : }
1942 : :
1943 : 268 : const region *buf_reg = model->deref_rvalue (str_sval, NULL_TREE, ctxt);
1944 : 268 : model->scan_for_null_terminator (buf_reg,
1945 : : NULL_TREE,
1946 : : nullptr,
1947 : : ctxt);
1948 : :
1949 : 268 : if (m_found)
1950 : : {
1951 : 134 : const region *str_reg
1952 : 134 : = model->deref_rvalue (str_sval, cd.get_arg_tree (0),
1953 : : cd.get_ctxt ());
1954 : : /* We want to figure out the start and nul terminator
1955 : : for the token.
1956 : : For each, we want str_sval + OFFSET for some unknown OFFSET.
1957 : : Use a conjured_svalue to represent the offset,
1958 : : using the str_reg as the id of the conjured_svalue. */
1959 : 134 : const svalue *start_offset
1960 : 134 : = mgr->get_or_create_conjured_svalue (size_type_node,
1961 : 134 : cd.get_call_stmt (),
1962 : : str_reg,
1963 : 134 : conjured_purge (model,
1964 : 134 : ctxt),
1965 : : 0);
1966 : 134 : const svalue *nul_offset
1967 : 134 : = mgr->get_or_create_conjured_svalue (size_type_node,
1968 : 134 : cd.get_call_stmt (),
1969 : : str_reg,
1970 : 134 : conjured_purge (model,
1971 : 134 : ctxt),
1972 : : 1);
1973 : :
1974 : 134 : tree char_ptr_type = build_pointer_type (char_type_node);
1975 : 134 : const svalue *result
1976 : 134 : = mgr->get_or_create_binop (char_ptr_type, POINTER_PLUS_EXPR,
1977 : : str_sval, start_offset);
1978 : 134 : cd.maybe_set_lhs (result);
1979 : :
1980 : : /* nul_offset + 1; the offset to use for the next call. */
1981 : 134 : const svalue *next_offset
1982 : 134 : = mgr->get_or_create_binop (size_type_node, PLUS_EXPR,
1983 : : nul_offset,
1984 : : mgr->get_or_create_int_cst
1985 : 134 : (char_type_node, 1));
1986 : :
1987 : : /* Write '\0' to str_sval[nul_offset]. */
1988 : 134 : const svalue *ptr_to_term
1989 : 134 : = mgr->get_or_create_binop (char_ptr_type, POINTER_PLUS_EXPR,
1990 : : str_sval, nul_offset);
1991 : 134 : const region *terminator_reg
1992 : 134 : = model->deref_rvalue (ptr_to_term, NULL_TREE, cd.get_ctxt ());
1993 : 134 : model->set_value (terminator_reg,
1994 : : mgr->get_or_create_unmergeable
1995 : 134 : (mgr->get_or_create_int_cst (char_type_node,
1996 : 134 : 0)),
1997 : : cd.get_ctxt ());
1998 : :
1999 : : /* Update saved ptr to be at [nul_offset + 1]. */
2000 : 134 : const svalue *ptr_to_next
2001 : 134 : = mgr->get_or_create_binop (cd.get_lhs_type (), POINTER_PLUS_EXPR,
2002 : : str_sval, next_offset);
2003 : 134 : model->set_value (&m_private_reg, ptr_to_next, ctxt);
2004 : : }
2005 : : else
2006 : 134 : if (tree lhs_type = cd.get_lhs_type ())
2007 : : {
2008 : 126 : const svalue *result
2009 : 126 : = mgr->get_or_create_int_cst (lhs_type, 0);
2010 : 126 : cd.maybe_set_lhs (result);
2011 : : }
2012 : : return true;
2013 : : }
2014 : : private:
2015 : : const private_region &m_private_reg;
2016 : : bool m_nonnull_str;
2017 : : bool m_found;
2018 : : }; // class strtok_call_info
2019 : :
2020 : 6398 : kf_strtok (region_model_manager &mgr)
2021 : 6398 : : m_private_reg (mgr.alloc_symbol_id (),
2022 : 6398 : mgr.get_root_region (),
2023 : : get_region_type (),
2024 : 6398 : "strtok buffer")
2025 : : {
2026 : 6398 : }
2027 : :
2028 : 1168 : bool matches_call_types_p (const call_details &cd) const final override
2029 : : {
2030 : 1168 : return (cd.num_args () == 2
2031 : 1168 : && POINTER_TYPE_P (cd.get_arg_type (0))
2032 : 2336 : && POINTER_TYPE_P (cd.get_arg_type (1)));
2033 : : }
2034 : :
2035 : 194 : void impl_call_post (const call_details &cd) const final override
2036 : : {
2037 : 194 : if (cd.get_ctxt ())
2038 : : {
2039 : : /* Four-way bifurcation, based on whether:
2040 : : - the str is non-null
2041 : : - the result is non-null
2042 : : Typically the str is either null or non-null at a particular site,
2043 : : so hopefully this will generally just lead to two out-edges. */
2044 : 190 : cd.get_ctxt ()->bifurcate
2045 : 190 : (make_unique<strtok_call_info> (cd, m_private_reg, false, false));
2046 : 190 : cd.get_ctxt ()->bifurcate
2047 : 190 : (make_unique<strtok_call_info> (cd, m_private_reg, false, true));
2048 : 190 : cd.get_ctxt ()->bifurcate
2049 : 190 : (make_unique<strtok_call_info> (cd, m_private_reg, true, false));
2050 : 190 : cd.get_ctxt ()->bifurcate
2051 : 190 : (make_unique<strtok_call_info> (cd, m_private_reg, true, true));
2052 : 190 : cd.get_ctxt ()->terminate_path ();
2053 : : }
2054 : 194 : }
2055 : :
2056 : : private:
2057 : 6398 : static tree get_region_type ()
2058 : : {
2059 : 6398 : return build_pointer_type (char_type_node);
2060 : : }
2061 : : const private_region m_private_reg;
2062 : : };
2063 : :
2064 : 3199 : class kf_ubsan_bounds : public internal_known_function
2065 : : {
2066 : : /* Empty. */
2067 : : };
2068 : :
2069 : : /* Handle calls to functions referenced by
2070 : : __attribute__((malloc(FOO))). */
2071 : :
2072 : : void
2073 : 513 : region_model::impl_deallocation_call (const call_details &cd)
2074 : : {
2075 : 513 : kf_free kf;
2076 : 513 : kf.impl_call_post (cd);
2077 : 513 : }
2078 : :
2079 : : static void
2080 : 6398 : register_atomic_builtins (known_function_manager &kfm)
2081 : : {
2082 : 6398 : kfm.add (BUILT_IN_ATOMIC_EXCHANGE, make_unique<kf_atomic_exchange> ());
2083 : 6398 : kfm.add (BUILT_IN_ATOMIC_EXCHANGE_N, make_unique<kf_atomic_exchange_n> ());
2084 : 6398 : kfm.add (BUILT_IN_ATOMIC_EXCHANGE_1, make_unique<kf_atomic_exchange_n> ());
2085 : 6398 : kfm.add (BUILT_IN_ATOMIC_EXCHANGE_2, make_unique<kf_atomic_exchange_n> ());
2086 : 6398 : kfm.add (BUILT_IN_ATOMIC_EXCHANGE_4, make_unique<kf_atomic_exchange_n> ());
2087 : 6398 : kfm.add (BUILT_IN_ATOMIC_EXCHANGE_8, make_unique<kf_atomic_exchange_n> ());
2088 : 6398 : kfm.add (BUILT_IN_ATOMIC_EXCHANGE_16, make_unique<kf_atomic_exchange_n> ());
2089 : 6398 : kfm.add (BUILT_IN_ATOMIC_LOAD, make_unique<kf_atomic_load> ());
2090 : 6398 : kfm.add (BUILT_IN_ATOMIC_LOAD_N, make_unique<kf_atomic_load_n> ());
2091 : 6398 : kfm.add (BUILT_IN_ATOMIC_LOAD_1, make_unique<kf_atomic_load_n> ());
2092 : 6398 : kfm.add (BUILT_IN_ATOMIC_LOAD_2, make_unique<kf_atomic_load_n> ());
2093 : 6398 : kfm.add (BUILT_IN_ATOMIC_LOAD_4, make_unique<kf_atomic_load_n> ());
2094 : 6398 : kfm.add (BUILT_IN_ATOMIC_LOAD_8, make_unique<kf_atomic_load_n> ());
2095 : 6398 : kfm.add (BUILT_IN_ATOMIC_LOAD_16, make_unique<kf_atomic_load_n> ());
2096 : 6398 : kfm.add (BUILT_IN_ATOMIC_STORE, make_unique<kf_atomic_store> ());
2097 : 6398 : kfm.add (BUILT_IN_ATOMIC_STORE_N, make_unique<kf_atomic_store_n> ());
2098 : 6398 : kfm.add (BUILT_IN_ATOMIC_STORE_1, make_unique<kf_atomic_store_n> ());
2099 : 6398 : kfm.add (BUILT_IN_ATOMIC_STORE_2, make_unique<kf_atomic_store_n> ());
2100 : 6398 : kfm.add (BUILT_IN_ATOMIC_STORE_4, make_unique<kf_atomic_store_n> ());
2101 : 6398 : kfm.add (BUILT_IN_ATOMIC_STORE_8, make_unique<kf_atomic_store_n> ());
2102 : 6398 : kfm.add (BUILT_IN_ATOMIC_STORE_16, make_unique<kf_atomic_store_n> ());
2103 : 6398 : kfm.add (BUILT_IN_ATOMIC_ADD_FETCH_1,
2104 : 12796 : make_unique<kf_atomic_op_fetch> (PLUS_EXPR));
2105 : 6398 : kfm.add (BUILT_IN_ATOMIC_ADD_FETCH_2,
2106 : 12796 : make_unique<kf_atomic_op_fetch> (PLUS_EXPR));
2107 : 6398 : kfm.add (BUILT_IN_ATOMIC_ADD_FETCH_4,
2108 : 12796 : make_unique<kf_atomic_op_fetch> (PLUS_EXPR));
2109 : 6398 : kfm.add (BUILT_IN_ATOMIC_ADD_FETCH_8,
2110 : 12796 : make_unique<kf_atomic_op_fetch> (PLUS_EXPR));
2111 : 6398 : kfm.add (BUILT_IN_ATOMIC_ADD_FETCH_16,
2112 : 12796 : make_unique<kf_atomic_op_fetch> (PLUS_EXPR));
2113 : 6398 : kfm.add (BUILT_IN_ATOMIC_SUB_FETCH_1,
2114 : 12796 : make_unique<kf_atomic_op_fetch> (MINUS_EXPR));
2115 : 6398 : kfm.add (BUILT_IN_ATOMIC_SUB_FETCH_2,
2116 : 12796 : make_unique<kf_atomic_op_fetch> (MINUS_EXPR));
2117 : 6398 : kfm.add (BUILT_IN_ATOMIC_SUB_FETCH_4,
2118 : 12796 : make_unique<kf_atomic_op_fetch> (MINUS_EXPR));
2119 : 6398 : kfm.add (BUILT_IN_ATOMIC_SUB_FETCH_8,
2120 : 12796 : make_unique<kf_atomic_op_fetch> (MINUS_EXPR));
2121 : 6398 : kfm.add (BUILT_IN_ATOMIC_SUB_FETCH_16,
2122 : 12796 : make_unique<kf_atomic_op_fetch> (MINUS_EXPR));
2123 : 6398 : kfm.add (BUILT_IN_ATOMIC_AND_FETCH_1,
2124 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_AND_EXPR));
2125 : 6398 : kfm.add (BUILT_IN_ATOMIC_AND_FETCH_2,
2126 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_AND_EXPR));
2127 : 6398 : kfm.add (BUILT_IN_ATOMIC_AND_FETCH_4,
2128 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_AND_EXPR));
2129 : 6398 : kfm.add (BUILT_IN_ATOMIC_AND_FETCH_8,
2130 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_AND_EXPR));
2131 : 6398 : kfm.add (BUILT_IN_ATOMIC_AND_FETCH_16,
2132 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_AND_EXPR));
2133 : 6398 : kfm.add (BUILT_IN_ATOMIC_XOR_FETCH_1,
2134 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_XOR_EXPR));
2135 : 6398 : kfm.add (BUILT_IN_ATOMIC_XOR_FETCH_2,
2136 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_XOR_EXPR));
2137 : 6398 : kfm.add (BUILT_IN_ATOMIC_XOR_FETCH_4,
2138 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_XOR_EXPR));
2139 : 6398 : kfm.add (BUILT_IN_ATOMIC_XOR_FETCH_8,
2140 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_XOR_EXPR));
2141 : 6398 : kfm.add (BUILT_IN_ATOMIC_XOR_FETCH_16,
2142 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_XOR_EXPR));
2143 : 6398 : kfm.add (BUILT_IN_ATOMIC_OR_FETCH_1,
2144 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_IOR_EXPR));
2145 : 6398 : kfm.add (BUILT_IN_ATOMIC_OR_FETCH_2,
2146 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_IOR_EXPR));
2147 : 6398 : kfm.add (BUILT_IN_ATOMIC_OR_FETCH_4,
2148 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_IOR_EXPR));
2149 : 6398 : kfm.add (BUILT_IN_ATOMIC_OR_FETCH_8,
2150 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_IOR_EXPR));
2151 : 6398 : kfm.add (BUILT_IN_ATOMIC_OR_FETCH_16,
2152 : 12796 : make_unique<kf_atomic_op_fetch> (BIT_IOR_EXPR));
2153 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_ADD_1,
2154 : 12796 : make_unique<kf_atomic_fetch_op> (PLUS_EXPR));
2155 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_ADD_2,
2156 : 12796 : make_unique<kf_atomic_fetch_op> (PLUS_EXPR));
2157 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_ADD_4,
2158 : 12796 : make_unique<kf_atomic_fetch_op> (PLUS_EXPR));
2159 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_ADD_8,
2160 : 12796 : make_unique<kf_atomic_fetch_op> (PLUS_EXPR));
2161 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_ADD_16,
2162 : 12796 : make_unique<kf_atomic_fetch_op> (PLUS_EXPR));
2163 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_SUB_1,
2164 : 12796 : make_unique<kf_atomic_fetch_op> (MINUS_EXPR));
2165 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_SUB_2,
2166 : 12796 : make_unique<kf_atomic_fetch_op> (MINUS_EXPR));
2167 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_SUB_4,
2168 : 12796 : make_unique<kf_atomic_fetch_op> (MINUS_EXPR));
2169 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_SUB_8,
2170 : 12796 : make_unique<kf_atomic_fetch_op> (MINUS_EXPR));
2171 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_SUB_16,
2172 : 12796 : make_unique<kf_atomic_fetch_op> (MINUS_EXPR));
2173 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_AND_1,
2174 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_AND_EXPR));
2175 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_AND_2,
2176 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_AND_EXPR));
2177 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_AND_4,
2178 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_AND_EXPR));
2179 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_AND_8,
2180 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_AND_EXPR));
2181 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_AND_16,
2182 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_AND_EXPR));
2183 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_XOR_1,
2184 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_XOR_EXPR));
2185 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_XOR_2,
2186 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_XOR_EXPR));
2187 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_XOR_4,
2188 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_XOR_EXPR));
2189 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_XOR_8,
2190 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_XOR_EXPR));
2191 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_XOR_16,
2192 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_XOR_EXPR));
2193 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_OR_1,
2194 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_IOR_EXPR));
2195 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_OR_2,
2196 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_IOR_EXPR));
2197 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_OR_4,
2198 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_IOR_EXPR));
2199 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_OR_8,
2200 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_IOR_EXPR));
2201 : 6398 : kfm.add (BUILT_IN_ATOMIC_FETCH_OR_16,
2202 : 12796 : make_unique<kf_atomic_fetch_op> (BIT_IOR_EXPR));
2203 : 6398 : }
2204 : :
2205 : : /* Handle calls to the various __builtin___ubsan_handle_*.
2206 : : These can return, but continuing after such a return
2207 : : isn't likely to be interesting to the user of the analyzer.
2208 : : Hence we terminate the analysis path at one of these calls. */
2209 : :
2210 : 3199 : class kf_ubsan_handler : public internal_known_function
2211 : : {
2212 : 13 : void impl_call_post (const call_details &cd) const final override
2213 : : {
2214 : 13 : if (cd.get_ctxt ())
2215 : 13 : cd.get_ctxt ()->terminate_path ();
2216 : 13 : }
2217 : : };
2218 : :
2219 : : static void
2220 : 3199 : register_sanitizer_builtins (known_function_manager &kfm)
2221 : : {
2222 : 3199 : kfm.add (BUILT_IN_UBSAN_HANDLE_NONNULL_ARG,
2223 : 6398 : make_unique<kf_ubsan_handler> ());
2224 : 3199 : }
2225 : :
2226 : : /* Populate KFM with instances of known functions supported by the core of the
2227 : : analyzer (as opposed to plugins). */
2228 : :
2229 : : void
2230 : 3199 : register_known_functions (known_function_manager &kfm,
2231 : : region_model_manager &rmm)
2232 : : {
2233 : : /* Debugging/test support functions, all with a "__analyzer_" prefix. */
2234 : 3199 : register_known_analyzer_functions (kfm);
2235 : :
2236 : : /* Internal fns the analyzer has known_functions for. */
2237 : 3199 : {
2238 : 3199 : kfm.add (IFN_BUILTIN_EXPECT, make_unique<kf_expect> ());
2239 : 3199 : kfm.add (IFN_UBSAN_BOUNDS, make_unique<kf_ubsan_bounds> ());
2240 : : }
2241 : :
2242 : : /* GCC built-ins that do not correspond to a function
2243 : : in the standard library. */
2244 : 3199 : {
2245 : 3199 : kfm.add (BUILT_IN_EXPECT, make_unique<kf_expect> ());
2246 : 3199 : kfm.add (BUILT_IN_EXPECT_WITH_PROBABILITY, make_unique<kf_expect> ());
2247 : 3199 : kfm.add (BUILT_IN_ALLOCA_WITH_ALIGN, make_unique<kf_alloca> ());
2248 : 3199 : kfm.add (BUILT_IN_STACK_RESTORE, make_unique<kf_stack_restore> ());
2249 : 3199 : kfm.add (BUILT_IN_STACK_SAVE, make_unique<kf_stack_save> ());
2250 : :
2251 : 3199 : register_atomic_builtins (kfm);
2252 : 3199 : register_sanitizer_builtins (kfm);
2253 : 3199 : register_varargs_builtins (kfm);
2254 : : }
2255 : :
2256 : : /* Known builtins and C standard library functions
2257 : : the analyzer has known functions for. */
2258 : 3199 : {
2259 : 3199 : kfm.add ("alloca", make_unique<kf_alloca> ());
2260 : 3199 : kfm.add ("__builtin_alloca", make_unique<kf_alloca> ());
2261 : 3199 : kfm.add ("calloc", make_unique<kf_calloc> ());
2262 : 3199 : kfm.add ("__builtin_calloc", make_unique<kf_calloc> ());
2263 : 3199 : kfm.add ("free", make_unique<kf_free> ());
2264 : 3199 : kfm.add ("__builtin_free", make_unique<kf_free> ());
2265 : 3199 : kfm.add ("malloc", make_unique<kf_malloc> ());
2266 : 3199 : kfm.add ("__builtin_malloc", make_unique<kf_malloc> ());
2267 : 3199 : kfm.add ("memcpy",
2268 : 6398 : make_unique<kf_memcpy_memmove> (kf_memcpy_memmove::KF_MEMCPY));
2269 : 3199 : kfm.add ("__builtin_memcpy",
2270 : 6398 : make_unique<kf_memcpy_memmove> (kf_memcpy_memmove::KF_MEMCPY));
2271 : 3199 : kfm.add ("__memcpy_chk", make_unique<kf_memcpy_memmove>
2272 : 6398 : (kf_memcpy_memmove::KF_MEMCPY_CHK));
2273 : 3199 : kfm.add ("__builtin___memcpy_chk", make_unique<kf_memcpy_memmove>
2274 : 6398 : (kf_memcpy_memmove::KF_MEMCPY_CHK));
2275 : 3199 : kfm.add ("memmove",
2276 : 6398 : make_unique<kf_memcpy_memmove> (kf_memcpy_memmove::KF_MEMMOVE));
2277 : 3199 : kfm.add ("__builtin_memmove",
2278 : 6398 : make_unique<kf_memcpy_memmove> (kf_memcpy_memmove::KF_MEMMOVE));
2279 : 3199 : kfm.add ("__memmove_chk", make_unique<kf_memcpy_memmove>
2280 : 6398 : (kf_memcpy_memmove::KF_MEMMOVE_CHK));
2281 : 3199 : kfm.add ("__builtin___memmove_chk", make_unique<kf_memcpy_memmove>
2282 : 6398 : (kf_memcpy_memmove::KF_MEMMOVE_CHK));
2283 : 3199 : kfm.add ("memset", make_unique<kf_memset> (false));
2284 : 3199 : kfm.add ("__builtin_memset", make_unique<kf_memset> (false));
2285 : 3199 : kfm.add ("__memset_chk", make_unique<kf_memset> (true));
2286 : 3199 : kfm.add ("__builtin___memset_chk", make_unique<kf_memset> (true));
2287 : 3199 : kfm.add ("realloc", make_unique<kf_realloc> ());
2288 : 3199 : kfm.add ("__builtin_realloc", make_unique<kf_realloc> ());
2289 : 3199 : kfm.add ("sprintf", make_unique<kf_sprintf> ());
2290 : 3199 : kfm.add ("__builtin_sprintf", make_unique<kf_sprintf> ());
2291 : 3199 : kfm.add ("strchr", make_unique<kf_strchr> ());
2292 : 3199 : kfm.add ("__builtin_strchr", make_unique<kf_strchr> ());
2293 : 3199 : kfm.add ("strcpy", make_unique<kf_strcpy> (2, false));
2294 : 3199 : kfm.add ("__builtin_strcpy", make_unique<kf_strcpy> (2, false));
2295 : 3199 : kfm.add ("__strcpy_chk", make_unique<kf_strcpy> (3, true));
2296 : 3199 : kfm.add ("__builtin___strcpy_chk", make_unique<kf_strcpy> (3, true));
2297 : 3199 : kfm.add ("strcat", make_unique<kf_strcat> (2, false));
2298 : 3199 : kfm.add ("__builtin_strcat", make_unique<kf_strcat> (2, false));
2299 : 3199 : kfm.add ("__strcat_chk", make_unique<kf_strcat> (3, true));
2300 : 3199 : kfm.add ("__builtin___strcat_chk", make_unique<kf_strcat> (3, true));
2301 : 3199 : kfm.add ("strdup", make_unique<kf_strdup> ());
2302 : 3199 : kfm.add ("__builtin_strdup", make_unique<kf_strdup> ());
2303 : 3199 : kfm.add ("strncpy", make_unique<kf_strncpy> ());
2304 : 3199 : kfm.add ("__builtin_strncpy", make_unique<kf_strncpy> ());
2305 : 3199 : kfm.add ("strndup", make_unique<kf_strndup> ());
2306 : 3199 : kfm.add ("__builtin_strndup", make_unique<kf_strndup> ());
2307 : 3199 : kfm.add ("strlen", make_unique<kf_strlen> ());
2308 : 3199 : kfm.add ("__builtin_strlen", make_unique<kf_strlen> ());
2309 : 3199 : kfm.add ("strstr", make_unique<kf_strstr> ());
2310 : 3199 : kfm.add ("__builtin_strstr", make_unique<kf_strstr> ());
2311 : :
2312 : 3199 : register_atomic_builtins (kfm);
2313 : 3199 : register_varargs_builtins (kfm);
2314 : : }
2315 : :
2316 : : /* Known POSIX functions, and some non-standard extensions. */
2317 : 3199 : {
2318 : 3199 : kfm.add ("fopen", make_unique<kf_fopen> ());
2319 : 3199 : kfm.add ("putenv", make_unique<kf_putenv> ());
2320 : 3199 : kfm.add ("strtok", make_unique<kf_strtok> (rmm));
2321 : :
2322 : 3199 : register_known_fd_functions (kfm);
2323 : 3199 : register_known_file_functions (kfm);
2324 : : }
2325 : :
2326 : : /* glibc functions. */
2327 : 3199 : {
2328 : 3199 : kfm.add ("__errno_location", make_unique<kf_errno_location> ());
2329 : 3199 : kfm.add ("error", make_unique<kf_error> (3));
2330 : 3199 : kfm.add ("error_at_line", make_unique<kf_error> (5));
2331 : : /* Variants of "error" and "error_at_line" seen by the
2332 : : analyzer at -O0 (PR analyzer/115724). */
2333 : 3199 : kfm.add ("__error_alias", make_unique<kf_error> (3));
2334 : 3199 : kfm.add ("__error_at_line_alias", make_unique<kf_error> (5));
2335 : : }
2336 : :
2337 : : /* Other implementations of C standard library. */
2338 : 3199 : {
2339 : : /* According to PR 107807 comment #2, Solaris implements "errno"
2340 : : like this:
2341 : : extern int *___errno(void) __attribute__((__const__));
2342 : : #define errno (*(___errno()))
2343 : : and macOS like this:
2344 : : extern int * __error(void);
2345 : : #define errno (*__error())
2346 : : and similarly __errno for newlib.
2347 : : Add these as synonyms for "__errno_location". */
2348 : 3199 : kfm.add ("___errno", make_unique<kf_errno_location> ());
2349 : 3199 : kfm.add ("__error", make_unique<kf_errno_location> ());
2350 : 3199 : kfm.add ("__errno", make_unique<kf_errno_location> ());
2351 : : }
2352 : :
2353 : : /* Language-specific support functions. */
2354 : 3199 : register_known_functions_lang_cp (kfm);
2355 : :
2356 : : /* Some C++ implementations use the std:: copies of these functions
2357 : : from <cstdlib> etc for the C spellings of these headers (e.g. <stdlib.h>),
2358 : : so we must match against these too. */
2359 : 3199 : {
2360 : 3199 : kfm.add_std_ns ("malloc", make_unique<kf_malloc> ());
2361 : 3199 : kfm.add_std_ns ("free", make_unique<kf_free> ());
2362 : 3199 : kfm.add_std_ns ("realloc", make_unique<kf_realloc> ());
2363 : 3199 : kfm.add_std_ns ("calloc", make_unique<kf_calloc> ());
2364 : 3199 : kfm.add_std_ns
2365 : 3199 : ("memcpy",
2366 : 6398 : make_unique<kf_memcpy_memmove> (kf_memcpy_memmove::KF_MEMCPY));
2367 : 3199 : kfm.add_std_ns
2368 : 3199 : ("memmove",
2369 : 6398 : make_unique<kf_memcpy_memmove> (kf_memcpy_memmove::KF_MEMMOVE));
2370 : 3199 : kfm.add_std_ns ("memset", make_unique<kf_memset> (false));
2371 : 3199 : kfm.add_std_ns ("strcat", make_unique<kf_strcat> (2, false));
2372 : 3199 : kfm.add_std_ns ("strcpy", make_unique<kf_strcpy> (2, false));
2373 : 3199 : kfm.add_std_ns ("strlen", make_unique<kf_strlen> ());
2374 : 3199 : kfm.add_std_ns ("strncpy", make_unique<kf_strncpy> ());
2375 : 3199 : kfm.add_std_ns ("strtok", make_unique<kf_strtok> (rmm));
2376 : : }
2377 : 3199 : }
2378 : :
2379 : : } // namespace ana
2380 : :
2381 : : #endif /* #if ENABLE_ANALYZER */
|
