Line data Source code
1 : /* Classes for working with summaries of function calls.
2 : Copyright (C) 2022 David Malcolm <dmalcolm@redhat.com>.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify it
7 : under the terms of the GNU General Public License as published by
8 : the Free Software Foundation; either version 3, or (at your option)
9 : any later version.
10 :
11 : GCC is distributed in the hope that it will be useful, but
12 : WITHOUT ANY WARRANTY; without even the implied warranty of
13 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : General Public License for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with GCC; see the file COPYING3. If not see
18 : <http://www.gnu.org/licenses/>. */
19 :
20 : #include "analyzer/common.h"
21 :
22 : #include "analyzer/region-model.h"
23 : #include "analyzer/call-summary.h"
24 : #include "analyzer/exploded-graph.h"
25 :
26 : #if ENABLE_ANALYZER
27 :
28 : namespace ana {
29 :
30 : /* class call_summary. */
31 :
32 : const program_state &
33 677 : call_summary::get_state () const
34 : {
35 677 : return m_enode->get_state ();
36 : }
37 :
38 : tree
39 28 : call_summary::get_fndecl () const
40 : {
41 28 : return m_enode->get_function ()->decl;
42 : }
43 :
44 : label_text
45 28 : call_summary::get_desc () const
46 : {
47 28 : pretty_printer pp;
48 28 : pp_format_decoder (&pp) = default_tree_printer;
49 :
50 28 : get_user_facing_desc (&pp);
51 28 : if (flag_analyzer_verbose_edges)
52 0 : pp_printf (&pp, " (call summary; EN: %i)", m_enode->m_index);
53 :
54 28 : return label_text::take (xstrdup (pp_formatted_text (&pp)));
55 28 : }
56 :
57 : /* Generate a user-facing description of this call summary.c
58 : This has various heuristics for distinguishing between different
59 : summaries.
60 : This will help with debugging, too. */
61 :
62 : void
63 28 : call_summary::get_user_facing_desc (pretty_printer *pp) const
64 : {
65 28 : tree fndecl = get_fndecl ();
66 :
67 : /* If there are multiple summaries, try to use the return value to
68 : distinguish between them. */
69 28 : if (m_per_fn_data->m_summaries.length () > 1)
70 : {
71 0 : if (tree result = DECL_RESULT (fndecl))
72 : {
73 0 : const region *result_reg
74 0 : = get_state ().m_region_model->get_lvalue (result, nullptr);
75 0 : const svalue *result_sval
76 0 : = get_state ().m_region_model->get_store_value (result_reg, nullptr);
77 0 : switch (result_sval->get_kind ())
78 : {
79 : default:
80 : break;
81 0 : case SK_POINTER:
82 0 : {
83 0 : const pointer_svalue *ptr_sval
84 0 : = as_a <const pointer_svalue *> (result_sval);
85 0 : const region *base_reg = &ptr_sval->get_base_region ();
86 0 : switch (base_reg->get_kind ())
87 : {
88 : default:
89 : break;
90 0 : case RK_HEAP_ALLOCATED:
91 0 : pp_printf (pp,
92 : "when %qE returns pointer"
93 : " to heap-allocated buffer",
94 : fndecl);
95 0 : return;
96 : }
97 : }
98 : break;
99 0 : case SK_CONSTANT:
100 0 : {
101 0 : const constant_svalue *constant_sval
102 0 : = as_a <const constant_svalue *> (result_sval);
103 0 : tree cst = constant_sval->get_constant ();
104 0 : if (POINTER_TYPE_P (TREE_TYPE (result))
105 0 : && zerop (cst))
106 0 : pp_printf (pp, "when %qE returns NULL", fndecl);
107 : else
108 0 : pp_printf (pp, "when %qE returns %qE", fndecl, cst);
109 : return;
110 : }
111 : }
112 : }
113 : }
114 :
115 : /* Fallback. */
116 28 : pp_printf (pp, "when %qE returns", fndecl);
117 : }
118 :
119 : void
120 0 : call_summary::dump_to_logger (logger &logger) const
121 : {
122 0 : symbolic::dump_node_tree_to_logger<call_summary> (*this, logger);
123 0 : }
124 :
125 : std::unique_ptr<text_art::tree_widget>
126 0 : call_summary::make_dump_widget (symbolic::node_dump_state &nds) const
127 : {
128 0 : using text_art::tree_widget;
129 :
130 0 : label_text desc = get_desc ();
131 0 : std::unique_ptr<tree_widget> summary_widget
132 0 : (tree_widget::from_fmt (nds, nullptr, "call_summary: %qs", desc.get ()));
133 :
134 0 : summary_widget->add_child (get_state ().make_dump_widget (nds));
135 :
136 0 : return summary_widget;
137 0 : }
138 :
139 : /* class call_summary_replay. */
140 :
141 : /* call_summary_replay's ctor.
142 : Populate the cache with params for the summary based on
143 : arguments at the caller. */
144 :
145 677 : call_summary_replay::call_summary_replay (const call_details &cd,
146 : const function &called_fn,
147 : call_summary &summary,
148 : const extrinsic_state &ext_state)
149 677 : : m_cd (cd),
150 677 : m_summary (summary),
151 677 : m_ext_state (ext_state)
152 : {
153 677 : region_model_manager *mgr = cd.get_manager ();
154 :
155 : // populate params based on args
156 677 : tree fndecl = called_fn.decl;
157 :
158 : /* Get a frame_region for use with respect to the summary.
159 : This will be a top-level frame, since that's what's in
160 : the summary. */
161 677 : const frame_region *summary_frame
162 677 : = mgr->get_frame_region (nullptr, called_fn);
163 :
164 677 : unsigned idx = 0;
165 1423 : for (tree iter_parm = DECL_ARGUMENTS (fndecl); iter_parm;
166 746 : iter_parm = DECL_CHAIN (iter_parm), ++idx)
167 : {
168 : /* If there's a mismatching declaration, the call stmt might
169 : not have enough args. Handle this case by leaving the
170 : rest of the params as uninitialized. */
171 746 : if (idx >= cd.num_args ())
172 : break;
173 746 : const svalue *caller_arg_sval = cd.get_arg_svalue (idx);
174 746 : tree parm_lval = iter_parm;
175 746 : if (tree parm_default_ssa = get_ssa_default_def (called_fn, iter_parm))
176 735 : parm_lval = parm_default_ssa;
177 746 : const region *summary_parm_reg
178 746 : = summary_frame->get_region_for_local (mgr, parm_lval, cd.get_ctxt ());
179 746 : const svalue *summary_initial_parm_reg
180 746 : = mgr->get_or_create_initial_value (summary_parm_reg);
181 746 : add_svalue_mapping (summary_initial_parm_reg, caller_arg_sval);
182 : }
183 :
184 : /* Handle any variadic args. */
185 677 : unsigned va_arg_idx = 0;
186 683 : for (; idx < cd.num_args (); idx++, va_arg_idx++)
187 : {
188 6 : const svalue *caller_arg_sval = cd.get_arg_svalue (idx);
189 6 : const region *summary_var_arg_reg
190 6 : = mgr->get_var_arg_region (summary_frame, va_arg_idx);
191 6 : const svalue *summary_initial_var_arg_reg
192 6 : = mgr->get_or_create_initial_value (summary_var_arg_reg);
193 6 : add_svalue_mapping (summary_initial_var_arg_reg, caller_arg_sval);
194 : }
195 677 : }
196 :
197 : /* Try to convert SUMMARY_SVAL in the summary to a corresponding svalue
198 : in the caller, caching the result.
199 :
200 : Return nullptr if the conversion is not possible. */
201 :
202 : const svalue *
203 6689 : call_summary_replay::convert_svalue_from_summary (const svalue *summary_sval)
204 : {
205 6689 : gcc_assert (summary_sval);
206 :
207 13378 : if (const svalue **slot
208 6689 : = m_map_svalue_from_summary_to_caller.get (summary_sval))
209 4228 : return *slot;
210 :
211 2461 : const svalue *caller_sval = convert_svalue_from_summary_1 (summary_sval);
212 :
213 2461 : if (caller_sval)
214 2179 : if (summary_sval->get_type () && caller_sval->get_type ())
215 2135 : gcc_assert (types_compatible_p (summary_sval->get_type (),
216 : caller_sval->get_type ()));
217 :
218 : /* Add to cache. */
219 2461 : add_svalue_mapping (summary_sval, caller_sval);
220 :
221 2461 : return caller_sval;
222 : }
223 :
224 : /* Implementation of call_summary_replay::convert_svalue_from_summary. */
225 :
226 : const svalue *
227 2461 : call_summary_replay::convert_svalue_from_summary_1 (const svalue *summary_sval)
228 : {
229 2461 : gcc_assert (summary_sval);
230 :
231 2461 : switch (summary_sval->get_kind ())
232 : {
233 0 : default:
234 0 : gcc_unreachable ();
235 141 : case SK_POINTER:
236 141 : {
237 141 : const pointer_svalue *region_summary_sval
238 141 : = as_a <const pointer_svalue *> (summary_sval);
239 141 : auto &summary_sym_ptr = region_summary_sval->get_symbolic_pointer ();
240 :
241 141 : const region *caller_base_reg
242 141 : = convert_region_from_summary (&summary_sym_ptr.get_base_region ());
243 141 : if (!caller_base_reg)
244 : return nullptr;
245 141 : auto *caller_byte_offset
246 141 : = convert_scalar_from_summary (summary_sym_ptr.get_byte_offset ());
247 141 : if (!caller_byte_offset)
248 : return nullptr;
249 133 : region_model_manager *mgr = get_manager ();
250 133 : return mgr->get_ptr_svalue (summary_sval->get_type (),
251 : symbolic::pointer (*caller_base_reg,
252 133 : *caller_byte_offset));
253 : }
254 : break;
255 :
256 : case SK_CONSTANT:
257 : case SK_PLACEHOLDER:
258 : case SK_POISONED:
259 : case SK_UNKNOWN:
260 : return summary_sval;
261 :
262 : case SK_SETJMP:
263 : return nullptr; // TODO
264 :
265 375 : case SK_INITIAL:
266 375 : {
267 375 : const initial_svalue *initial_summary_sval
268 375 : = as_a <const initial_svalue *> (summary_sval);
269 : /* Params should already be in the cache, courtesy of the ctor. */
270 375 : gcc_assert (!initial_summary_sval->initial_value_of_param_p ());
271 :
272 : /* Initial value of region within the summary is the value of the
273 : region at the point of the call. */
274 375 : const region *summary_reg = initial_summary_sval->get_region ();
275 375 : const region *caller_reg = convert_region_from_summary (summary_reg);
276 375 : if (!caller_reg)
277 : return nullptr;
278 375 : const svalue *caller_sval
279 375 : = m_cd.get_model ()->get_store_value (caller_reg, m_cd.get_ctxt ());
280 375 : return caller_sval;
281 : }
282 88 : break;
283 88 : case SK_UNARYOP:
284 88 : {
285 88 : const unaryop_svalue *unaryop_summary_sval
286 88 : = as_a <const unaryop_svalue *> (summary_sval);
287 88 : const svalue *summary_arg = unaryop_summary_sval->get_arg ();
288 88 : const svalue *caller_arg = convert_svalue_from_summary (summary_arg);
289 88 : if (!caller_arg)
290 : return nullptr;
291 64 : region_model_manager *mgr = get_manager ();
292 64 : return mgr->get_or_create_unaryop (summary_sval->get_type (),
293 : unaryop_summary_sval->get_op (),
294 64 : caller_arg);
295 : }
296 474 : break;
297 474 : case SK_BINOP:
298 474 : {
299 474 : const binop_svalue *binop_summary_sval
300 474 : = as_a <const binop_svalue *> (summary_sval);
301 474 : const svalue *summary_arg0 = binop_summary_sval->get_arg0 ();
302 474 : const svalue *caller_arg0 = convert_svalue_from_summary (summary_arg0);
303 474 : if (!caller_arg0)
304 : return nullptr;
305 429 : const svalue *summary_arg1 = binop_summary_sval->get_arg1 ();
306 429 : const svalue *caller_arg1 = convert_svalue_from_summary (summary_arg1);
307 429 : if (!caller_arg1)
308 : return nullptr;
309 421 : region_model_manager *mgr = get_manager ();
310 421 : return mgr->get_or_create_binop (summary_sval->get_type (),
311 : binop_summary_sval->get_op (),
312 : caller_arg0,
313 421 : caller_arg1);
314 : }
315 361 : break;
316 361 : case SK_BIT_VECTOR:
317 361 : {
318 361 : auto *sval_from_bv
319 361 : = as_a<const svalue_from_bit_vector *> (summary_sval);
320 361 : auto *caller_bv
321 361 : = convert_bit_vector_from_summary (sval_from_bv->get_bit_vector ());
322 361 : if (!caller_bv)
323 : return nullptr;
324 180 : region_model_manager *mgr = get_manager ();
325 180 : return mgr->get_svalue_from_bit_vector (summary_sval->get_type (),
326 180 : *caller_bv);
327 : }
328 0 : break;
329 0 : case SK_UNMERGEABLE:
330 0 : {
331 0 : const unmergeable_svalue *unmergeable_summary_sval
332 0 : = as_a <const unmergeable_svalue *> (summary_sval);
333 0 : const svalue *summary_arg_sval = unmergeable_summary_sval->get_arg ();
334 0 : const svalue *caller_arg_sval
335 0 : = convert_svalue_from_summary (summary_arg_sval);
336 0 : if (!caller_arg_sval)
337 : return nullptr;
338 0 : region_model_manager *mgr = get_manager ();
339 0 : return mgr->get_or_create_unmergeable (caller_arg_sval);
340 : }
341 114 : break;
342 114 : case SK_WIDENING:
343 114 : {
344 114 : const widening_svalue *widening_summary_sval
345 114 : = as_a <const widening_svalue *> (summary_sval);
346 114 : const supernode *snode = widening_summary_sval->get_snode ();
347 114 : const svalue *summary_base_sval
348 114 : = widening_summary_sval->get_base_svalue ();
349 114 : const svalue *caller_base_sval
350 114 : = convert_svalue_from_summary (summary_base_sval);
351 228 : if (!(caller_base_sval
352 114 : && caller_base_sval->can_have_associated_state_p ()))
353 : return nullptr;
354 98 : const svalue *summary_iter_sval
355 98 : = widening_summary_sval->get_iter_svalue ();
356 98 : const svalue *caller_iter_sval
357 98 : = convert_svalue_from_summary (summary_iter_sval);
358 196 : if (!(caller_iter_sval
359 98 : && caller_iter_sval->can_have_associated_state_p ()))
360 : return nullptr;
361 98 : region_model_manager *mgr = get_manager ();
362 98 : return mgr->get_or_create_widening_svalue
363 98 : (summary_iter_sval->get_type (),
364 : snode,
365 : caller_base_sval,
366 98 : caller_iter_sval);
367 : }
368 8 : break;
369 8 : case SK_ASM_OUTPUT:
370 8 : {
371 8 : const asm_output_svalue *asm_output_summary_sval
372 8 : = as_a <const asm_output_svalue *> (summary_sval);
373 8 : const char *asm_string = asm_output_summary_sval->get_asm_string ();
374 8 : unsigned output_idx = asm_output_summary_sval->get_output_idx ();
375 8 : unsigned num_inputs = asm_output_summary_sval->get_num_inputs ();
376 8 : unsigned num_outputs = asm_output_summary_sval->get_num_outputs ();
377 8 : auto_vec<const svalue *> inputs (num_inputs);
378 16 : for (unsigned idx = 0; idx < num_inputs; idx++)
379 : {
380 0 : const svalue *summary_input
381 0 : = asm_output_summary_sval->get_input (idx);
382 0 : const svalue *caller_input
383 0 : = convert_svalue_from_summary (summary_input);
384 0 : if (!caller_input)
385 0 : return nullptr;
386 0 : inputs.safe_push (caller_input);
387 : }
388 8 : region_model_manager *mgr = get_manager ();
389 8 : return mgr->get_or_create_asm_output_svalue (summary_sval->get_type (),
390 : asm_string,
391 : output_idx,
392 : num_outputs,
393 8 : inputs);
394 8 : }
395 2 : break;
396 2 : case SK_CONST_FN_RESULT:
397 2 : {
398 2 : const const_fn_result_svalue *const_fn_result_summary_sval
399 2 : = as_a <const const_fn_result_svalue *> (summary_sval);
400 2 : tree fndecl = const_fn_result_summary_sval->get_fndecl ();
401 2 : unsigned num_inputs = const_fn_result_summary_sval->get_num_inputs ();
402 2 : auto_vec<const svalue *> inputs (num_inputs);
403 6 : for (unsigned idx = 0; idx < num_inputs; idx++)
404 : {
405 2 : const svalue *summary_input
406 2 : = const_fn_result_summary_sval->get_input (idx);
407 2 : const svalue *caller_input
408 2 : = convert_svalue_from_summary (summary_input);
409 2 : if (!caller_input)
410 0 : return nullptr;
411 2 : inputs.safe_push (caller_input);
412 : }
413 2 : region_model_manager *mgr = get_manager ();
414 2 : return mgr->get_or_create_const_fn_result_svalue
415 2 : (summary_sval->get_type (),
416 : fndecl,
417 2 : inputs);
418 2 : }
419 : break;
420 : }
421 : }
422 :
423 : /* Try to convert SUMMARY_REG in the summary to a corresponding region
424 : in the caller, caching the result.
425 :
426 : Return nullptr if the conversion is not possible. */
427 :
428 : const region *
429 3115 : call_summary_replay::convert_region_from_summary (const region *summary_reg)
430 : {
431 3115 : gcc_assert (summary_reg);
432 :
433 6230 : if (const region **slot
434 3115 : = m_map_region_from_summary_to_caller.get (summary_reg))
435 980 : return *slot;
436 :
437 2135 : const region *caller_reg = convert_region_from_summary_1 (summary_reg);
438 :
439 2135 : if (caller_reg)
440 1990 : if (summary_reg->get_type () && caller_reg->get_type ())
441 1854 : gcc_assert (types_compatible_p (summary_reg->get_type (),
442 : caller_reg->get_type ()));
443 :
444 : /* Add to cache. */
445 2135 : add_region_mapping (summary_reg, caller_reg);
446 :
447 2135 : return caller_reg;
448 : }
449 :
450 : /* Implementation of call_summary_replay::convert_region_from_summary. */
451 :
452 : const region *
453 2135 : call_summary_replay::convert_region_from_summary_1 (const region *summary_reg)
454 : {
455 2135 : gcc_assert (summary_reg);
456 :
457 2135 : region_model_manager *mgr = get_manager ();
458 2135 : switch (summary_reg->get_kind ())
459 : {
460 0 : default:
461 0 : gcc_unreachable ();
462 : /* Top-level regions. */
463 0 : case RK_FRAME:
464 0 : case RK_GLOBALS:
465 0 : case RK_CODE:
466 0 : case RK_STACK:
467 0 : case RK_HEAP:
468 0 : case RK_THREAD_LOCAL:
469 0 : case RK_ROOT:
470 : /* These should never be pointed to by a pointer_svalue. */
471 0 : gcc_unreachable ();
472 :
473 : case RK_FUNCTION:
474 : case RK_LABEL:
475 : case RK_STRING:
476 : case RK_ERRNO:
477 : case RK_UNKNOWN:
478 : case RK_PRIVATE:
479 : /* We can reuse these regions directly. */
480 : return summary_reg;
481 :
482 550 : case RK_SYMBOLIC:
483 550 : {
484 550 : const symbolic_region *summary_symbolic_reg
485 550 : = as_a <const symbolic_region *> (summary_reg);
486 550 : const svalue *summary_ptr_sval = summary_symbolic_reg->get_pointer ();
487 550 : const svalue *caller_ptr_sval
488 550 : = convert_svalue_from_summary (summary_ptr_sval);
489 550 : if (!caller_ptr_sval)
490 : return nullptr;
491 474 : const region *caller_reg
492 474 : = get_caller_model ()->deref_rvalue (caller_ptr_sval,
493 : NULL_TREE,
494 : get_ctxt ());
495 474 : caller_reg = mgr->get_cast_region (caller_reg,
496 : summary_reg->get_type ());
497 474 : return caller_reg;
498 : }
499 1372 : break;
500 :
501 1372 : case RK_DECL:
502 1372 : {
503 1372 : const decl_region *summary_decl_reg
504 1372 : = as_a <const decl_region *> (summary_reg);
505 1372 : tree decl = summary_decl_reg->get_decl ();
506 1372 : switch (TREE_CODE (decl))
507 : {
508 0 : default:
509 0 : gcc_unreachable ();
510 : case SSA_NAME:
511 : /* We don't care about writes to locals within
512 : the summary. */
513 : return nullptr;
514 1017 : case VAR_DECL:
515 : /* We don't care about writes to locals within
516 : the summary. */
517 1017 : if (is_global_var (decl))
518 : /* If it's a global, we can reuse the region directly. */
519 : return summary_reg;
520 : else
521 : /* Otherwise, we don't care about locals. */
522 : return nullptr;
523 291 : case RESULT_DECL:
524 291 : return m_cd.get_lhs_region ();
525 : case PARM_DECL:
526 : /* Writes (by value) to parms should be visible to the caller. */
527 : return nullptr;
528 : }
529 : }
530 0 : break;
531 0 : case RK_FIELD:
532 0 : {
533 0 : const field_region *summary_field_reg
534 0 : = as_a <const field_region *> (summary_reg);
535 0 : const region *summary_parent_reg = summary_reg->get_parent_region ();
536 0 : const region *caller_parent_reg
537 0 : = convert_region_from_summary (summary_parent_reg);
538 0 : if (!caller_parent_reg)
539 : return nullptr;
540 0 : tree field = summary_field_reg->get_field ();
541 0 : return mgr->get_field_region (caller_parent_reg, field);
542 : }
543 0 : break;
544 0 : case RK_ELEMENT:
545 0 : {
546 0 : const element_region *summary_element_reg
547 0 : = as_a <const element_region *> (summary_reg);
548 0 : const region *summary_parent_reg = summary_reg->get_parent_region ();
549 0 : const region *caller_parent_reg
550 0 : = convert_region_from_summary (summary_parent_reg);
551 0 : if (!caller_parent_reg)
552 : return nullptr;
553 0 : const svalue *summary_index = summary_element_reg->get_index ();
554 0 : const svalue *caller_index
555 0 : = convert_svalue_from_summary (summary_index);
556 0 : if (!caller_index)
557 : return nullptr;
558 0 : return mgr->get_element_region (caller_parent_reg,
559 : summary_reg->get_type (),
560 0 : caller_index);
561 : }
562 0 : break;
563 0 : case RK_OFFSET:
564 0 : {
565 0 : const offset_region *summary_offset_reg
566 0 : = as_a <const offset_region *> (summary_reg);
567 0 : const region *summary_parent_reg = summary_reg->get_parent_region ();
568 0 : const region *caller_parent_reg
569 0 : = convert_region_from_summary (summary_parent_reg);
570 0 : if (!caller_parent_reg)
571 : return nullptr;
572 0 : const svalue *summary_byte_offset
573 0 : = summary_offset_reg->get_byte_offset ();
574 0 : const svalue *caller_byte_offset
575 0 : = convert_svalue_from_summary (summary_byte_offset);
576 0 : if (!caller_byte_offset)
577 : return nullptr;
578 0 : return mgr->get_offset_region (caller_parent_reg,
579 : summary_reg->get_type (),
580 0 : caller_byte_offset);
581 : }
582 0 : break;
583 0 : case RK_SIZED:
584 0 : {
585 0 : const sized_region *summary_sized_reg
586 0 : = as_a <const sized_region *> (summary_reg);
587 0 : const region *summary_parent_reg = summary_reg->get_parent_region ();
588 0 : const region *caller_parent_reg
589 0 : = convert_region_from_summary (summary_parent_reg);
590 0 : if (!caller_parent_reg)
591 : return nullptr;
592 0 : const svalue *summary_byte_size
593 0 : = summary_sized_reg->get_byte_size_sval (mgr);
594 0 : const svalue *caller_byte_size
595 0 : = convert_svalue_from_summary (summary_byte_size);
596 0 : if (!caller_byte_size)
597 : return nullptr;
598 0 : return mgr->get_sized_region (caller_parent_reg,
599 : summary_reg->get_type (),
600 0 : caller_byte_size);
601 : }
602 0 : break;
603 0 : case RK_CAST:
604 0 : {
605 0 : const region *summary_parent_reg = summary_reg->get_parent_region ();
606 0 : const region *caller_parent_reg
607 0 : = convert_region_from_summary (summary_parent_reg);
608 0 : if (!caller_parent_reg)
609 : return nullptr;
610 0 : return mgr->get_cast_region (caller_parent_reg,
611 0 : summary_reg->get_type ());
612 : }
613 136 : break;
614 136 : case RK_HEAP_ALLOCATED:
615 136 : {
616 : /* If we have a heap-allocated region in the summary, then
617 : it was allocated within the callee.
618 : Create a new heap-allocated region to summarize this. */
619 136 : auto_bitmap heap_regs_in_use;
620 136 : get_caller_model ()->get_referenced_base_regions (heap_regs_in_use);
621 136 : return mgr->get_or_create_region_for_heap_alloc (heap_regs_in_use);
622 136 : }
623 : break;
624 : case RK_ALLOCA:
625 : return nullptr;
626 0 : case RK_BIT_RANGE:
627 0 : {
628 0 : const bit_range_region *summary_bit_range_reg
629 0 : = as_a <const bit_range_region *> (summary_reg);
630 0 : const region *summary_parent_reg = summary_reg->get_parent_region ();
631 0 : const region *caller_parent_reg
632 0 : = convert_region_from_summary (summary_parent_reg);
633 0 : if (!caller_parent_reg)
634 : return nullptr;
635 0 : const concrete_bit_range &bits = summary_bit_range_reg->get_bits ();
636 0 : return mgr->get_bit_range (caller_parent_reg,
637 : summary_reg->get_type (),
638 0 : bits);
639 : }
640 : break;
641 : case RK_VAR_ARG:
642 : return nullptr;
643 : }
644 : }
645 :
646 : /* Try to convert SUMMARY_BC in the summary to a corresponding bit_contents
647 : in the caller.
648 :
649 : Return nullptr if the conversion is not possible. */
650 :
651 : const symbolic::bit_contents *
652 3123 : call_summary_replay::
653 : convert_bit_contents_from_summary (const symbolic::bit_contents &summary_bc)
654 : {
655 3123 : auto &bc_mgr = summary_bc.get_bit_contents_manager ();
656 3123 : switch (summary_bc.get_kind ())
657 : {
658 0 : default:
659 0 : gcc_unreachable ();
660 :
661 : case symbolic::bit_contents::kind::uninit:
662 : case symbolic::bit_contents::kind::zero:
663 : return &summary_bc;
664 :
665 738 : case symbolic::bit_contents::kind::untracked:
666 738 : {
667 738 : auto &summary_untracked
668 : = (const symbolic::untracked_bit_contents &)summary_bc;
669 738 : value_set maybe_live_caller;
670 1575 : for (auto iter : summary_untracked.get_maybe_live ())
671 : {
672 837 : if (auto *sval = iter->dyn_cast_svalue ())
673 : {
674 458 : if (auto *caller_sval = convert_svalue_from_summary (sval))
675 378 : maybe_live_caller.add (caller_sval);
676 : }
677 379 : else if (auto *bv = iter->dyn_cast_bit_vector ())
678 : {
679 379 : if (auto *caller_bv = convert_bit_vector_from_summary (*bv))
680 331 : maybe_live_caller.add (caller_bv);
681 : }
682 : else
683 0 : gcc_unreachable ();
684 : }
685 738 : return &bc_mgr.get_untracked (maybe_live_caller);
686 738 : }
687 714 : break;
688 :
689 714 : case symbolic::bit_contents::kind::baseline:
690 714 : {
691 714 : auto &summary_baseline
692 : = (const symbolic::baseline_bit_contents &)summary_bc;
693 :
694 714 : auto &summary_baseline_key = summary_baseline.get_baseline_key ();
695 714 : auto *caller_reg
696 714 : = convert_region_from_summary (summary_baseline_key.m_base_reg);
697 714 : if (!caller_reg)
698 : return nullptr;
699 :
700 : /* Note that caller_reg might not itself be a base region;
701 : get its offset within its base region. */
702 470 : auto &rmm = summary_bc.get_node_mgr ().get_region_model_manager ();
703 470 : auto caller_mem_offset = caller_reg->get_memory_offset (rmm);
704 :
705 : /* We want the state of base_reg in the caller at the call,
706 : rather than at its baseline. */
707 470 : region_model *caller_model = get_caller_model ();
708 470 : auto *caller_cluster
709 470 : = caller_model->get_store ()->get_cluster (&caller_mem_offset.get_base_region ());
710 470 : if (!caller_cluster)
711 : return nullptr;
712 333 : auto &caller_bc = caller_cluster->get_bit_contents ();
713 333 : return &bc_mgr.get_offset_bit_contents
714 333 : (caller_bc,
715 333 : -caller_mem_offset.get_bit_offset ());
716 : }
717 : break;
718 :
719 : case symbolic::bit_contents::kind::conjured:
720 : return nullptr; // TODO
721 :
722 : case symbolic::bit_contents::kind::named_test:
723 : return nullptr; // TODO
724 :
725 863 : case symbolic::bit_contents::kind::concrete_overlay:
726 863 : {
727 863 : auto &summary_overlay
728 : = (const symbolic::concrete_bit_overlay &)summary_bc;
729 863 : auto *caller_baseline
730 863 : = convert_bit_contents_from_summary (summary_overlay.get_baseline ());
731 863 : if (!caller_baseline)
732 : return nullptr;
733 862 : auto *caller_result = caller_baseline;
734 1545 : for (auto iter : summary_overlay.m_concrete_range_map)
735 : {
736 894 : auto &summary_bv = iter.second;
737 894 : auto *caller_bv
738 894 : = convert_bit_vector_from_summary (summary_bv);
739 894 : if (!caller_bv)
740 211 : return nullptr;
741 683 : caller_result
742 683 : = &caller_result->set_bits (iter.first, *caller_bv, nullptr);
743 894 : }
744 651 : return caller_result;
745 : }
746 34 : break;
747 34 : case symbolic::bit_contents::kind::symbolic_overlay:
748 34 : {
749 34 : auto &summary_overlay
750 : = (const symbolic::symbolic_bit_overlay &)summary_bc;
751 34 : auto *caller_baseline
752 34 : = convert_bit_contents_from_summary (summary_overlay.get_baseline ());
753 34 : if (!caller_baseline)
754 : return nullptr;
755 34 : symbolic::symbolic_bit_overlay::key caller_key {caller_baseline, {}};
756 68 : for (auto iter : summary_overlay.m_symbolic_range_map)
757 : {
758 34 : auto &summary_bit_range = iter.first;
759 34 : auto &summary_bv = iter.second;
760 34 : auto *caller_start_offset = convert_scalar_from_summary
761 34 : (summary_bit_range.get_start_offset ());
762 34 : if (!caller_start_offset)
763 34 : return nullptr;
764 34 : auto *caller_size
765 34 : = convert_scalar_from_summary (summary_bit_range.get_size ());
766 34 : if (!caller_size)
767 : return nullptr;
768 34 : auto *caller_bv
769 34 : = convert_bit_vector_from_summary (summary_bv);
770 34 : if (!caller_bv)
771 : return nullptr;
772 34 : caller_key.m_symbolic_range_map.insert
773 34 : ({symbolic_bit_range (*caller_start_offset, *caller_size),
774 : *caller_bv});
775 : }
776 34 : return &bc_mgr.get_symbolic_bit_overlay (std::move (caller_key),
777 : nullptr /* FIMXE: uncertainty */);
778 34 : }
779 : break;
780 : case symbolic::bit_contents::kind::offset:
781 : return nullptr; // TODO
782 : }
783 : }
784 :
785 : /* Try to convert SUMMARY_BV in the summary to a corresponding bit_vector
786 : in the caller.
787 :
788 : Return nullptr if the conversion is not possible. */
789 :
790 : const symbolic::bit_vector *
791 1670 : call_summary_replay::
792 : convert_bit_vector_from_summary (const symbolic::bit_vector &summary_bv)
793 : {
794 1670 : auto &bv_mgr = summary_bv.get_bit_vector_manager ();
795 1670 : switch (summary_bv.get_kind ())
796 : {
797 0 : default:
798 0 : gcc_unreachable ();
799 :
800 : case symbolic::bit_vector::kind::concat:
801 : return nullptr; // TODO
802 :
803 69 : case symbolic::bit_vector::kind::conjured:
804 69 : {
805 69 : auto &summary_conjured_bv
806 : = (const symbolic::conjured_bit_vector &)summary_bv;
807 :
808 69 : auto *caller_id_reg
809 69 : = convert_region_from_summary (summary_conjured_bv.get_id_reg ());
810 69 : if (!caller_id_reg)
811 : return nullptr;
812 :
813 62 : conjured_purge p (get_caller_model (), get_ctxt ());
814 62 : auto &caller_bv
815 62 : = bv_mgr.get_conjured_bits (summary_conjured_bv.get_stmt (),
816 : caller_id_reg,
817 : p,
818 : summary_conjured_bv.get_idx ());
819 62 : return &caller_bv;
820 : }
821 2 : break;
822 2 : case symbolic::bit_vector::kind::cropped:
823 2 : {
824 2 : auto &summary_cropped_bv
825 : = (const symbolic::cropped_bit_vector &)summary_bv;
826 2 : auto &summary_uncropped_bv
827 2 : = summary_cropped_bv.get_uncropped_bit_vector ();
828 2 : auto *caller_uncropped_bv
829 2 : = convert_bit_vector_from_summary (summary_uncropped_bv);
830 2 : if (!caller_uncropped_bv)
831 : return nullptr;
832 2 : auto summary_bit_range
833 2 : = summary_cropped_bv.get_uncropped_bits_to_use ();
834 2 : auto *caller_start_offset
835 2 : = convert_scalar_from_summary (summary_bit_range.get_start_offset ());
836 2 : if (!caller_start_offset)
837 : return nullptr;
838 2 : auto *caller_size
839 2 : = convert_scalar_from_summary (summary_bit_range.get_size ());
840 2 : return &bv_mgr.get_cropped_bits
841 2 : (*caller_uncropped_bv,
842 2 : symbolic_bit_range (*caller_start_offset,
843 2 : *caller_size));
844 : }
845 : break;
846 :
847 : case symbolic::bit_vector::kind::empty:
848 : case symbolic::bit_vector::kind::named_test:
849 : case symbolic::bit_vector::kind::poisoned:
850 : return &summary_bv;
851 :
852 : case symbolic::bit_vector::kind::repeated:
853 : return nullptr; // TODO
854 :
855 714 : case symbolic::bit_vector::kind::svalue:
856 714 : {
857 714 : auto &summary_bv_for_sval
858 : = (const symbolic::bit_vector_from_svalue &)summary_bv;
859 714 : auto &summary_sval = summary_bv_for_sval.get_svalue ();
860 714 : auto *caller_sval = convert_svalue_from_summary (&summary_sval);
861 714 : if (!caller_sval)
862 : return nullptr;
863 661 : return &bv_mgr.get_bit_vector_from_svalue (*caller_sval);
864 : }
865 687 : break;
866 :
867 687 : case symbolic::bit_vector::kind::from_ubc:
868 687 : {
869 687 : auto &summary_bv_from_ubc
870 : = (const symbolic::bit_vector_from_ubc &)summary_bv;
871 687 : auto &summary_bc = summary_bv_from_ubc.get_bit_contents ();
872 687 : auto *caller_bc = convert_bit_contents_from_summary (summary_bc);
873 687 : if (!caller_bc)
874 : return nullptr;
875 :
876 307 : auto &summary_sym_bit_range = summary_bv_from_ubc.get_bit_range ();
877 307 : auto *caller_start_offset
878 307 : = convert_scalar_from_summary (summary_sym_bit_range.get_start_offset ());
879 307 : if (!caller_start_offset)
880 : return nullptr;
881 307 : auto *caller_size
882 307 : = convert_scalar_from_summary (summary_sym_bit_range.get_size ());
883 307 : if (!caller_size)
884 : return nullptr;
885 307 : return &caller_bc->get_bits (symbolic_bit_range (*caller_start_offset,
886 307 : *caller_size));
887 : }
888 : break;
889 : case symbolic::bit_vector::kind::tristate:
890 : return &summary_bv;
891 : }
892 : }
893 :
894 : template <typename ConcreteValueType>
895 : const symbolic::scalar<ConcreteValueType> *
896 0 : call_summary_replay::impl_bits_from_bytes (const symbolic::scalar<ConcreteValueType> &summary_scalar)
897 : {
898 0 : gcc_unreachable ();
899 : }
900 :
901 : template <>
902 : const symbolic_bit_size *
903 96 : call_summary_replay::impl_bits_from_bytes (const symbolic_bit_size &summary_scalar)
904 : {
905 96 : auto &summary_from_bytes
906 : = (const symbolic::bits_from_bytes_scalar &)summary_scalar;
907 96 : auto &summary_bytes = summary_from_bytes.get_bytes ();
908 96 : auto *caller_bytes = convert_scalar_from_summary (summary_bytes);
909 96 : if (!caller_bytes)
910 : return nullptr;
911 96 : auto &scalar_mgr = summary_scalar.get_mgr ();
912 96 : return &scalar_mgr.get_bits_from_bytes (*caller_bytes);
913 : }
914 :
915 : template <typename ConcreteValueType>
916 : const symbolic::scalar<ConcreteValueType> *
917 955 : call_summary_replay::
918 : convert_scalar_from_summary (const symbolic::scalar<ConcreteValueType> &summary_scalar)
919 : {
920 955 : switch (summary_scalar.get_kind ())
921 : {
922 0 : default:
923 0 : gcc_unreachable ();
924 : case symbolic::scalar<ConcreteValueType>::kind::concrete:
925 : return &summary_scalar;
926 :
927 0 : case symbolic::scalar<ConcreteValueType>::kind::sum:
928 : {
929 0 : auto &summary_sum
930 : = (const symbolic::sum<ConcreteValueType> &)summary_scalar;
931 :
932 0 : auto &scalar_mgr = summary_scalar.get_mgr ();
933 0 : std::vector<const symbolic::scalar<ConcreteValueType> *> caller_addends;
934 0 : for (size_t i = 0; i < summary_sum.get_num_symbolic_addends (); ++i)
935 : {
936 0 : auto &summary_addend = summary_sum.get_symbolic_addend (i);
937 0 : auto *caller_addend = convert_scalar_from_summary (summary_addend);
938 0 : gcc_assert (caller_addend);
939 0 : caller_addends.push_back (caller_addend);
940 : }
941 0 : if (auto *summary_conc_addend = summary_sum.get_any_concrete_addend ())
942 0 : caller_addends.push_back (summary_conc_addend);
943 0 : return &scalar_mgr.get_sum (std::move (caller_addends));
944 0 : }
945 : break;
946 :
947 16 : case symbolic::scalar<ConcreteValueType>::kind::product:
948 : {
949 16 : auto &summary_product
950 : = (const symbolic::product<ConcreteValueType> &)summary_scalar;
951 : auto *caller_lhs
952 16 : = convert_scalar_from_summary (summary_product.get_lhs ());
953 16 : if (!caller_lhs)
954 : return nullptr;
955 : auto *caller_rhs
956 16 : = convert_scalar_from_summary (summary_product.get_rhs ());
957 16 : if (!caller_rhs)
958 : return nullptr;
959 16 : auto &scalar_mgr = summary_scalar.get_mgr ();
960 16 : return &scalar_mgr.get_product (*caller_lhs, *caller_rhs);
961 : }
962 : break;
963 :
964 128 : case symbolic::scalar<ConcreteValueType>::kind::from_svalue:
965 : {
966 128 : auto &summary_from_sval
967 : = (const symbolic::scalar_from_svalue<ConcreteValueType> &)summary_scalar;
968 : auto *caller_sval
969 128 : = convert_svalue_from_summary (&summary_from_sval.get_svalue ());
970 128 : if (!caller_sval)
971 : return nullptr;
972 120 : auto &scalar_mgr = summary_scalar.get_mgr ();
973 120 : return &scalar_mgr.get_scalar_from_svalue (*caller_sval);
974 : }
975 : break;
976 :
977 : case symbolic::scalar<ConcreteValueType>::kind::named_test:
978 : return &summary_scalar;
979 :
980 96 : case symbolic::scalar<ConcreteValueType>::kind::bits_from_bytes:
981 96 : return impl_bits_from_bytes (summary_scalar);
982 : }
983 : }
984 :
985 : /* Record that SUMMARY_SVAL maps to CALLER_SVAL for this replay. */
986 :
987 : void
988 3213 : call_summary_replay::add_svalue_mapping (const svalue *summary_sval,
989 : const svalue *caller_sval)
990 : {
991 3213 : gcc_assert (summary_sval);
992 : // CALLER_SVAL can be nullptr
993 3213 : m_map_svalue_from_summary_to_caller.put (summary_sval, caller_sval);
994 3213 : }
995 :
996 : /* Record that SUMMARY_REG maps to CALLER_REG for this replay. */
997 :
998 : void
999 2135 : call_summary_replay::add_region_mapping (const region *summary_reg,
1000 : const region *caller_reg)
1001 : {
1002 2135 : gcc_assert (summary_reg);
1003 : // CALLER_REG can be nullptr
1004 2135 : m_map_region_from_summary_to_caller.put (summary_reg, caller_reg);
1005 2135 : }
1006 :
1007 : std::unique_ptr<text_art::tree_widget>
1008 0 : call_summary_replay::make_dump_widget (symbolic::node_dump_state &nds) const
1009 : {
1010 0 : using text_art::tree_widget;
1011 0 : std::unique_ptr<tree_widget> replay_widget
1012 0 : (tree_widget::from_fmt (nds, nullptr, "call_summary_replay"));
1013 :
1014 0 : replay_widget->add_child (m_cd.make_dump_widget (nds));
1015 0 : replay_widget->add_child (m_summary.make_dump_widget (nds));
1016 :
1017 : /* Current state of caller (could be in mid-update). */
1018 0 : {
1019 0 : auto w = tree_widget::from_fmt (nds, nullptr, "Current state of caller");
1020 0 : w->add_child (m_cd.get_model ()->make_dump_widget (nds));
1021 0 : replay_widget->add_child (std::move (w));
1022 0 : }
1023 :
1024 0 : {
1025 0 : auto details_widget = tree_widget::from_fmt (nds, nullptr, "Replay state");
1026 :
1027 0 : {
1028 0 : auto sval_map_widget = tree_widget::from_fmt
1029 0 : (nds, nullptr, "svalue mappings from summary to caller:");
1030 :
1031 0 : auto_vec <const svalue *> summary_svals;
1032 0 : for (auto kv : m_map_svalue_from_summary_to_caller)
1033 0 : summary_svals.safe_push (kv.first);
1034 0 : summary_svals.qsort (svalue::cmp_ptr_ptr);
1035 0 : for (auto summary_sval : summary_svals)
1036 : {
1037 0 : auto in_summary_widget = tree_widget::from_fmt
1038 0 : (nds, nullptr, "sval in summary:");
1039 0 : in_summary_widget->add_child (summary_sval->make_dump_widget (nds));
1040 0 : sval_map_widget->add_child (std::move (in_summary_widget));
1041 :
1042 0 : const svalue *caller_sval
1043 : = *((const_cast<svalue_map_t &>
1044 0 : (m_map_svalue_from_summary_to_caller)).get (summary_sval));
1045 0 : auto in_caller_widget = tree_widget::from_fmt
1046 0 : (nds, nullptr, "sval in caller:");
1047 0 : in_caller_widget->add_child (caller_sval->make_dump_widget (nds));
1048 0 : sval_map_widget->add_child (std::move (in_caller_widget));
1049 0 : }
1050 :
1051 0 : details_widget->add_child (std::move (sval_map_widget));
1052 0 : }
1053 :
1054 0 : {
1055 0 : auto reg_map_widget = tree_widget::from_fmt
1056 0 : (nds, nullptr, "region mappings from summary to caller:");
1057 :
1058 0 : auto_vec <const region *> summary_regs;
1059 0 : for (auto kv : m_map_region_from_summary_to_caller)
1060 0 : summary_regs.safe_push (kv.first);
1061 0 : summary_regs.qsort (region::cmp_ptr_ptr);
1062 0 : for (auto summary_reg : summary_regs)
1063 : {
1064 0 : auto in_summary_widget = tree_widget::from_fmt
1065 0 : (nds, nullptr, "reg in summary:");
1066 0 : if (summary_reg)
1067 0 : in_summary_widget->add_child (summary_reg->make_dump_widget (nds));
1068 : else
1069 0 : in_summary_widget->add_child
1070 0 : (tree_widget::from_fmt (nds, nullptr, "(null)"));
1071 0 : reg_map_widget->add_child (std::move (in_summary_widget));
1072 :
1073 0 : const region *caller_reg
1074 : = *((const_cast<region_map_t &>
1075 0 : (m_map_region_from_summary_to_caller)).get (summary_reg));
1076 0 : auto in_caller_widget = tree_widget::from_fmt
1077 0 : (nds, nullptr, "reg in caller:");
1078 0 : if (caller_reg)
1079 0 : in_caller_widget->add_child (caller_reg->make_dump_widget (nds));
1080 : else
1081 0 : in_caller_widget->add_child
1082 0 : (tree_widget::from_fmt (nds, nullptr, "(null)"));
1083 0 : reg_map_widget->add_child (std::move (in_caller_widget));
1084 0 : }
1085 :
1086 0 : details_widget->add_child (std::move (reg_map_widget));
1087 0 : }
1088 :
1089 0 : replay_widget->add_child (std::move (details_widget));
1090 0 : }
1091 :
1092 0 : return replay_widget;
1093 : }
1094 :
1095 : /* Dump a tree-like representation of this object to stderr. */
1096 :
1097 : DEBUG_FUNCTION void
1098 0 : call_summary_replay::dump () const
1099 : {
1100 0 : symbolic::dump_node_tree_to_stderr<call_summary_replay> (*this);
1101 0 : }
1102 :
1103 : /* Dump a tree-like representation of this object to LOG. */
1104 :
1105 : void
1106 0 : call_summary_replay::dump_to_logger (logger &log) const
1107 : {
1108 0 : symbolic::dump_node_tree_to_logger<call_summary_replay> (*this, log);
1109 0 : }
1110 :
1111 : } // namespace ana
1112 :
1113 : #endif /* #if ENABLE_ANALYZER */
|