Line data Source code
1 : /* Regions of memory.
2 : Copyright (C) 2019-2026 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 "analyzer/common.h"
22 :
23 : #include "ordered-hash-map.h"
24 : #include "options.h"
25 : #include "cgraph.h"
26 : #include "cfg.h"
27 : #include "digraph.h"
28 : #include "sbitmap.h"
29 : #include "fold-const.h"
30 : #include "tree-ssa.h"
31 :
32 : #include "diagnostics/markup.h"
33 :
34 : #include "analyzer/analyzer-logging.h"
35 : #include "analyzer/supergraph.h"
36 : #include "analyzer/call-string.h"
37 : #include "analyzer/program-point.h"
38 : #include "analyzer/store.h"
39 : #include "analyzer/region.h"
40 : #include "analyzer/region-model.h"
41 : #include "analyzer/sm.h"
42 : #include "analyzer/program-state.h"
43 : #include "analyzer/symbolic-pointers.h"
44 : #include "text-art/dump.h"
45 :
46 : #if ENABLE_ANALYZER
47 :
48 : namespace ana {
49 :
50 : /* class region and its various subclasses. */
51 :
52 : /* class region. */
53 :
54 255801 : region::~region ()
55 : {
56 255801 : }
57 :
58 : void
59 5255 : region::print_dump_widget_label (pretty_printer *pp) const
60 : {
61 5255 : if (get_type ())
62 2118 : pp_printf (pp, "%qT: ", get_type ());
63 :
64 5255 : start_any_dump_color (pp);
65 5255 : print_region_for_dump_widget_label (pp);
66 5255 : end_any_dump_color (pp);
67 5255 : }
68 :
69 : void
70 4656 : region::
71 : add_dump_widget_children (text_art::tree_widget &w,
72 : symbolic::node_dump_state &nds) const
73 : {
74 4656 : add_dump_widget_children_for_region (w, nds);
75 4656 : if (m_parent)
76 6274 : w.add_child (m_parent->make_dump_widget (nds, "parent"));
77 4656 : }
78 :
79 : /* Determine the base region for this region: when considering bindings
80 : for this region, the base region is the ancestor which identifies
81 : which cluster they should be partitioned into.
82 : Regions within the same struct/union/array are in the same cluster.
83 : Different decls are in different clusters. */
84 :
85 : const region *
86 23616416 : region::get_base_region () const
87 : {
88 23616416 : const region *iter = this;
89 23623720 : while (iter)
90 : {
91 23623720 : switch (iter->get_kind ())
92 : {
93 7304 : case RK_FIELD:
94 7304 : case RK_ELEMENT:
95 7304 : case RK_OFFSET:
96 7304 : case RK_SIZED:
97 7304 : case RK_BIT_RANGE:
98 7304 : case RK_CAST:
99 7304 : iter = iter->get_parent_region ();
100 7304 : continue;
101 : default:
102 : return iter;
103 : }
104 : }
105 : return iter;
106 : }
107 :
108 : /* Return true if get_base_region() == this for this region. */
109 :
110 : bool
111 904074 : region::base_region_p () const
112 : {
113 904074 : switch (get_kind ())
114 : {
115 : /* Region kinds representing a descendent of a base region. */
116 : case RK_FIELD:
117 : case RK_ELEMENT:
118 : case RK_OFFSET:
119 : case RK_SIZED:
120 : case RK_CAST:
121 : case RK_BIT_RANGE:
122 : return false;
123 :
124 904074 : default:
125 904074 : return true;
126 : }
127 : }
128 :
129 : /* Return true if this region is ELDER or one of its descendents. */
130 :
131 : bool
132 208013 : region::descendent_of_p (const region *elder) const
133 : {
134 208013 : const region *iter = this;
135 776370 : while (iter)
136 : {
137 619284 : if (iter == elder)
138 : return true;
139 568357 : iter = iter->get_parent_region ();
140 : }
141 : return false;
142 : }
143 :
144 : /* If this region is a frame_region, or a descendent of one, return it.
145 : Otherwise return nullptr. */
146 :
147 : const frame_region *
148 1144413 : region::maybe_get_frame_region () const
149 : {
150 1144413 : const region *iter = this;
151 2493772 : while (iter)
152 : {
153 2390478 : if (const frame_region *frame_reg = iter->dyn_cast_frame_region ())
154 : return frame_reg;
155 1349359 : iter = iter->get_parent_region ();
156 : }
157 : return nullptr;
158 : }
159 :
160 : /* Get the memory space of this region. */
161 :
162 : enum memory_space
163 623547 : region::get_memory_space () const
164 : {
165 623549 : const region *iter = this;
166 1262206 : while (iter)
167 : {
168 1143334 : switch (iter->get_kind ())
169 : {
170 : default:
171 : break;
172 : case RK_GLOBALS:
173 : return MEMSPACE_GLOBALS;
174 : case RK_CODE:
175 : case RK_FUNCTION:
176 : case RK_LABEL:
177 : return MEMSPACE_CODE;
178 : case RK_FRAME:
179 : case RK_STACK:
180 : case RK_ALLOCA:
181 : return MEMSPACE_STACK;
182 : case RK_HEAP:
183 : case RK_HEAP_ALLOCATED:
184 : return MEMSPACE_HEAP;
185 : case RK_STRING:
186 : return MEMSPACE_READONLY_DATA;
187 : case RK_PRIVATE:
188 : return MEMSPACE_PRIVATE;
189 116155 : case RK_SYMBOLIC:
190 116155 : {
191 116155 : auto *sym_reg = as_a<const symbolic_region *> (iter);
192 116155 : const svalue *sval = sym_reg->get_pointer ();
193 116155 : if (auto *sym_ptr = sval->maybe_get_symbolic_pointer ())
194 2 : return sym_ptr->get_base_region ().get_memory_space ();
195 : }
196 : break;
197 : }
198 638657 : iter = iter->get_parent_region ();
199 : }
200 : return MEMSPACE_UNKNOWN;
201 : }
202 :
203 : /* Subroutine for use by region_model_manager::get_or_create_initial_value.
204 : Return true if this region has an initial_svalue.
205 : Return false if attempting to use INIT_VAL(this_region) should give
206 : the "UNINITIALIZED" poison value. */
207 :
208 : bool
209 187746 : region::can_have_initial_svalue_p () const
210 : {
211 187746 : const region *base_reg = get_base_region ();
212 :
213 : /* Check for memory spaces that are uninitialized by default. */
214 187746 : enum memory_space mem_space = base_reg->get_memory_space ();
215 187746 : switch (mem_space)
216 : {
217 0 : default:
218 0 : gcc_unreachable ();
219 : case MEMSPACE_UNKNOWN:
220 : case MEMSPACE_CODE:
221 : case MEMSPACE_GLOBALS:
222 : case MEMSPACE_READONLY_DATA:
223 : case MEMSPACE_PRIVATE:
224 : /* Such regions have initial_svalues. */
225 : return true;
226 :
227 : case MEMSPACE_HEAP:
228 : /* Heap allocations are uninitialized by default. */
229 : return false;
230 :
231 169034 : case MEMSPACE_STACK:
232 169034 : if (tree decl = base_reg->maybe_get_decl ())
233 : {
234 : /* See the assertion in frame_region::get_region_for_local for the
235 : tree codes we need to handle here. */
236 167934 : switch (TREE_CODE (decl))
237 : {
238 0 : default:
239 0 : gcc_unreachable ();
240 :
241 : case PARM_DECL:
242 : /* Parameters have initial values. */
243 : return true;
244 :
245 : case VAR_DECL:
246 : case RESULT_DECL:
247 : /* Function locals don't have initial values. */
248 : return false;
249 :
250 151871 : case SSA_NAME:
251 151871 : {
252 : /* Some SSA names have an implicit default defined value. */
253 151871 : tree ssa_name = decl;
254 151871 : if (SSA_NAME_IS_DEFAULT_DEF (ssa_name))
255 64869 : return ssa_defined_default_def_p (ssa_name);
256 : /* Others don't. */
257 : return false;
258 : }
259 : }
260 : }
261 :
262 : /* If we have an on-stack region that isn't associated with a decl
263 : or SSA name, then we have VLA/alloca, which is uninitialized. */
264 : return false;
265 : }
266 : }
267 :
268 : /* For regions within a global decl, get the svalue for the initial
269 : value of this region when the program starts, caching the result. */
270 :
271 : const svalue *
272 816 : region::get_initial_value_at_main (region_model_manager *mgr) const
273 : {
274 816 : if (!m_cached_init_sval_at_main)
275 816 : m_cached_init_sval_at_main = calc_initial_value_at_main (mgr);
276 816 : return m_cached_init_sval_at_main;
277 : }
278 :
279 : /* Implementation of region::get_initial_value_at_main. */
280 :
281 : const svalue *
282 816 : region::calc_initial_value_at_main (region_model_manager *mgr) const
283 : {
284 816 : if (auto decl_reg = get_base_region ()->dyn_cast_decl_region ())
285 : {
286 : /* Attempt to get the initializer value for base_reg. */
287 1180 : if (const svalue *base_reg_init
288 590 : = decl_reg->get_svalue_for_initializer (mgr))
289 : return base_reg_init;
290 : }
291 : // TODO: what about string_region?
292 :
293 : /* Otherwise, return INIT_VAL(REG). */
294 783 : return mgr->get_or_create_initial_value (this);
295 : }
296 :
297 : /* If this region is a decl_region, return the decl.
298 : Otherwise return NULL_TREE. */
299 :
300 : tree
301 2860274 : region::maybe_get_decl () const
302 : {
303 2860274 : if (const decl_region *decl_reg = dyn_cast_decl_region ())
304 2384352 : return decl_reg->get_decl ();
305 : return NULL_TREE;
306 : }
307 :
308 : symbolic::memory_offset
309 421449 : region::get_memory_offset (region_model_manager &mgr) const
310 : {
311 421449 : if(!m_cached_memory_offset)
312 : {
313 148230 : auto &node_mgr = mgr.get_node_manager ();
314 148230 : auto mem_offset = calc_memory_offset (node_mgr);
315 148230 : m_cached_memory_offset
316 148230 : = std::make_unique<symbolic::memory_offset> (mem_offset);
317 : }
318 421449 : return *m_cached_memory_offset;
319 : }
320 :
321 : /* Get the symbolic::memory_range for this region (calculating it on the
322 : first call and caching it internally). */
323 :
324 : symbolic::memory_range
325 2820888 : region::get_memory_range (region_model_manager &mgr) const
326 : {
327 2820888 : if(!m_cached_memory_range)
328 : {
329 142065 : auto &node_mgr = mgr.get_node_manager ();
330 142065 : auto mem_range = calc_memory_range (node_mgr);
331 142065 : m_cached_memory_range
332 142065 : = std::make_unique<symbolic::memory_range> (mem_range);
333 : }
334 2820888 : return *m_cached_memory_range;
335 : }
336 :
337 : symbolic::pointer
338 1041970 : region::get_pointer (region_model_manager &mgr) const
339 : {
340 1041970 : if(!m_cached_pointer)
341 : {
342 32480 : auto &node_mgr = mgr.get_node_manager ();
343 32480 : auto pointer = calc_pointer (node_mgr);
344 32480 : m_cached_pointer = std::make_unique<symbolic::pointer> (pointer);
345 : }
346 1041970 : return *m_cached_pointer;
347 : }
348 :
349 : /* Base class implementation of region::get_byte_size vfunc.
350 : If the size of this region (in bytes) is known statically, return it.
351 : Otherwise return nullptr. */
352 :
353 : const symbolic_byte_size *
354 36281 : region::
355 : maybe_get_byte_size (symbolic::scalar_manager<concrete_byte_size> &byte_mgr) const
356 : {
357 36281 : tree type = get_type ();
358 :
359 : /* Bail out e.g. for heap-allocated regions. */
360 36281 : if (!type)
361 : return nullptr;
362 :
363 805 : HOST_WIDE_INT bytes = int_size_in_bytes (type);
364 805 : if (bytes == -1)
365 : return nullptr;
366 :
367 645 : return &byte_mgr.get_concrete (concrete_byte_size (bytes));
368 : }
369 :
370 : /* Base implementation of region::get_byte_size_sval vfunc. */
371 :
372 : const svalue *
373 55514 : region::get_byte_size_sval (region_model_manager *mgr) const
374 : {
375 55514 : auto &byte_mgr = mgr->get_node_manager ().get_scalars ().get_bytes ();
376 55514 : auto *byte_size = maybe_get_byte_size (byte_mgr);
377 55514 : if (!byte_size)
378 35636 : return mgr->get_or_create_unknown_svalue (size_type_node);
379 :
380 19878 : return mgr->get_svalue_from_scalar<concrete_byte_size> (size_type_node,
381 19878 : *byte_size);
382 : }
383 :
384 : /* Attempt to get the size of TYPE in bits.
385 : If successful, return true and write the size to *OUT.
386 : Otherwise return false. */
387 :
388 : bool
389 3961026 : int_size_in_bits (const_tree type, bit_size_t *out)
390 : {
391 3961026 : if (INTEGRAL_TYPE_P (type))
392 : {
393 2120939 : *out = TYPE_PRECISION (type);
394 2120939 : return true;
395 : }
396 :
397 1840087 : tree sz = TYPE_SIZE (type);
398 1840087 : if (sz
399 1839447 : && tree_fits_uhwi_p (sz)
400 : /* If the size is zero, then we may have a zero-sized
401 : array; handle such cases by returning false. */
402 3679521 : && !integer_zerop (sz))
403 : {
404 1839164 : *out = TREE_INT_CST_LOW (sz);
405 1839164 : return true;
406 : }
407 : else
408 : return false;
409 : }
410 :
411 : /* Attempt to get the size of TYPE in bits. If successful,
412 : write it to *out and return true. Otherwise, return false. */
413 :
414 : bool
415 78025 : get_type_size (const_tree type, concrete_bit_size *out)
416 : {
417 78025 : if (INTEGRAL_TYPE_P (type))
418 : {
419 52834 : *out = concrete_bit_size (TYPE_PRECISION (type));
420 52834 : return true;
421 : }
422 :
423 25191 : tree sz = TYPE_SIZE (type);
424 25191 : if (sz
425 24816 : && tree_fits_uhwi_p (sz)
426 : /* If the size is zero, then we may have a zero-sized
427 : array; handle such cases by returning false. */
428 50007 : && !integer_zerop (sz))
429 : {
430 24732 : *out = concrete_bit_size (TREE_INT_CST_LOW (sz));
431 24732 : return true;
432 : }
433 : else
434 : return false;
435 : }
436 :
437 : concrete_bit_offset
438 21795 : get_bit_position (const_tree field)
439 : {
440 21795 : return concrete_bit_offset (int_bit_position (field));
441 : }
442 :
443 : /* If the size of this region (in bits) is known statically, return it.
444 : Otherwise return nullptr. */
445 :
446 : const symbolic_bit_size *
447 2570412 : region::
448 : maybe_get_bit_size (symbolic::scalar_manager<concrete_bit_size> &bit_mgr) const
449 : {
450 2570412 : tree type = get_type ();
451 :
452 : /* Bail out e.g. for heap-allocated regions. */
453 2570412 : if (!type)
454 : return nullptr;
455 :
456 2560309 : bit_size_t size;
457 2560309 : if (!int_size_in_bits (type, &size))
458 : return nullptr;
459 :
460 2559579 : concrete_bit_size conc_size = convert_from_bit_size_t (size);
461 2559579 : return &bit_mgr.get_concrete (conc_size);
462 2559579 : }
463 :
464 : /* Get the field within RECORD_TYPE at BIT_OFFSET. */
465 :
466 : tree
467 27940 : get_field_at_bit_offset (tree record_type, concrete_bit_offset bit_offset)
468 : {
469 27940 : gcc_assert (TREE_CODE (record_type) == RECORD_TYPE);
470 27940 : if (bit_offset < 0_bits)
471 : return nullptr;
472 :
473 : /* Find the first field that has an offset > BIT_OFFSET,
474 : then return the one preceding it.
475 : Skip other trees within the chain, such as FUNCTION_DECLs. */
476 27932 : tree last_field = NULL_TREE;
477 331617 : for (tree iter = TYPE_FIELDS (record_type); iter != NULL_TREE;
478 303685 : iter = DECL_CHAIN (iter))
479 : {
480 321713 : if (TREE_CODE (iter) == FIELD_DECL)
481 : {
482 69668 : concrete_bit_offset iter_field_offset
483 69668 : = concrete_bit_offset (int_bit_position (iter));
484 69668 : if (bit_offset < iter_field_offset)
485 18028 : return last_field;
486 51640 : last_field = iter;
487 69668 : }
488 : }
489 : return last_field;
490 : }
491 :
492 : /* Populate *OUT with descendent regions of type TYPE that match
493 : RELATIVE_BIT_RANGE within this region.
494 : If TYPE is null, then don't check for matching types, just bit ranges. */
495 :
496 : void
497 700069 : region::get_subregions_for_bit_range (region_model_manager *mgr,
498 : concrete_bit_range relative_bit_range,
499 : tree type,
500 : auto_vec <const region *> *out) const
501 : {
502 700069 : if (get_type () == NULL_TREE)
503 : return;
504 690950 : if (relative_bit_range.get_start_offset () == 0_bits)
505 : {
506 667607 : if (type && types_compatible_p (get_type (), type))
507 : {
508 6484 : out->safe_push (this);
509 6484 : return;
510 : }
511 661123 : if (type == NULL_TREE)
512 : {
513 : // For the null type case, check extents of this region
514 658693 : symbolic::memory_range reg_mem_range = get_memory_range (*mgr);
515 658693 : concrete_bit_size reg_conc_size;
516 658693 : if (concrete_from_symbolic (reg_mem_range.get_size (), ®_conc_size))
517 658279 : if (reg_conc_size == relative_bit_range.get_size ())
518 : {
519 639044 : out->safe_push (this);
520 639044 : return;
521 : }
522 658693 : }
523 : }
524 45422 : switch (TREE_CODE (get_type ()))
525 : {
526 10773 : case ARRAY_TYPE:
527 10773 : {
528 10773 : tree element_type = TREE_TYPE (get_type ());
529 10773 : concrete_byte_size byte_size
530 10773 : = concrete_byte_size (int_size_in_bytes (element_type));
531 10773 : if (byte_size > 0_bytes)
532 : {
533 10773 : auto bits_per_element = bits_from_bytes (byte_size);
534 10773 : auto element_index = (relative_bit_range.get_start_offset ()
535 10773 : .floor_div (bits_per_element));
536 10773 : tree element_index_cst
537 10773 : = make_integer_cst_from_integer (integer_type_node, element_index, false);
538 10773 : auto inner_bit_offset = element_index * bits_per_element;
539 10773 : const region *subregion = mgr->get_element_region
540 10773 : (this, element_type,
541 : mgr->get_or_create_constant_svalue (element_index_cst));
542 10773 : subregion->get_subregions_for_bit_range
543 21546 : (mgr,
544 10773 : concrete_bit_range (relative_bit_range.get_start_offset ()
545 21546 : - inner_bit_offset,
546 32319 : relative_bit_range.get_size ()),
547 : type, out);
548 10773 : }
549 10773 : }
550 10773 : break;
551 27940 : case RECORD_TYPE:
552 27940 : {
553 : /* The bit offset might be *within* one of the fields (such as
554 : with nested structs).
555 : So we want to find the enclosing field, adjust the offset,
556 : and repeat. */
557 27940 : if (tree field = get_field_at_bit_offset
558 27940 : (get_type (),
559 55880 : relative_bit_range.get_start_offset ()))
560 : {
561 26471 : concrete_bit_offset field_bit_offset
562 26471 : = concrete_bit_offset (int_bit_position (field));
563 26471 : const region *subregion = mgr->get_field_region (this, field);
564 26471 : subregion->get_subregions_for_bit_range
565 52942 : (mgr,
566 26471 : concrete_bit_range (relative_bit_range.get_start_offset ()
567 52942 : - field_bit_offset,
568 79413 : relative_bit_range.get_size ()),
569 : type, out);
570 26471 : }
571 : }
572 : break;
573 642 : case UNION_TYPE:
574 642 : {
575 5722 : for (tree field = TYPE_FIELDS (get_type ()); field != NULL_TREE;
576 5080 : field = DECL_CHAIN (field))
577 : {
578 5080 : if (TREE_CODE (field) != FIELD_DECL)
579 3488 : continue;
580 1592 : const region *subregion = mgr->get_field_region (this, field);
581 3184 : subregion->get_subregions_for_bit_range (mgr,
582 : relative_bit_range,
583 : type,
584 : out);
585 : }
586 : }
587 : break;
588 : default:
589 : /* Do nothing. */
590 : break;
591 : }
592 : }
593 :
594 : /* Walk from this region up to the base region within its cluster,
595 : accumulating the symbolic offset in bits relative to the base region.
596 : Calculate a symbolic size in bits.
597 : Return the (base region, symbolic offset, symbolic size) as a
598 : symbolic::memory_offset. */
599 :
600 : symbolic::memory_offset
601 148230 : region::calc_memory_offset (symbolic::node_manager &mgr) const
602 : {
603 148230 : const region *iter_region = this;
604 148230 : const region *base_region = nullptr;
605 :
606 148230 : auto &bit_mgr = mgr.get_scalars ().get_bits ();
607 148230 : const symbolic::scalar<integer_with_unit<units::bit>> *accum_bit_offset
608 148230 : = &bit_mgr.get_concrete (0_bits);
609 :
610 181658 : while (iter_region)
611 : {
612 181658 : switch (iter_region->get_kind ())
613 : {
614 25127 : case RK_FIELD:
615 25127 : case RK_ELEMENT:
616 25127 : case RK_OFFSET:
617 25127 : case RK_BIT_RANGE:
618 25127 : {
619 25127 : auto &rmm = mgr.get_region_model_manager ();
620 25127 : auto *bit_offset
621 25127 : = iter_region->maybe_get_bit_offset_relative_to_parent (rmm);
622 25127 : gcc_assert (bit_offset);
623 25127 : accum_bit_offset = &(*accum_bit_offset + *bit_offset);
624 25127 : iter_region = iter_region->get_parent_region ();
625 : }
626 25127 : continue;
627 :
628 8301 : case RK_SIZED:
629 8301 : case RK_CAST:
630 8301 : iter_region = iter_region->get_parent_region ();
631 8301 : continue;
632 :
633 12167 : case RK_SYMBOLIC:
634 12167 : {
635 12167 : const symbolic_region *sym_reg
636 12167 : = as_a<const symbolic_region *> (iter_region);
637 12167 : if (auto *sym_ptr
638 12167 : = sym_reg->get_pointer ()->maybe_get_symbolic_pointer ())
639 : {
640 55 : base_region = &sym_ptr->get_base_region ();
641 55 : iter_region = nullptr;
642 55 : accum_bit_offset
643 : = &(*accum_bit_offset
644 55 : + bits_from_bytes (sym_ptr->get_byte_offset ()));
645 55 : break;
646 : }
647 : }
648 : /* Fall through. */
649 :
650 : default:
651 : base_region = iter_region;
652 : iter_region = nullptr;
653 : break;
654 33428 : }
655 : }
656 :
657 148230 : gcc_assert (base_region);
658 :
659 148230 : return symbolic::memory_offset (*base_region, *accum_bit_offset);
660 : }
661 :
662 : /* Get the symbolic::memory_range for this region. */
663 :
664 : symbolic::memory_range
665 142065 : region::calc_memory_range (symbolic::node_manager &mgr) const
666 : {
667 142065 : symbolic::memory_offset mem_offset
668 142065 : = get_memory_offset (mgr.get_svalue_manager ());
669 142065 : auto &bit_mgr = mgr.get_scalars ().get_bits ();
670 142065 : auto *size = maybe_get_bit_size (bit_mgr);
671 142065 : if (!size)
672 615 : size = &bit_mgr.get_unknown ();
673 :
674 142065 : return symbolic::memory_range
675 : (mem_offset.get_base_region (),
676 142065 : symbolic_bit_range (mem_offset.get_bit_offset (), *size));
677 : }
678 :
679 : /* Walk from this region up to the base region within its cluster,
680 : accumulating the symbolic offset in bytes relative to the base region. */
681 :
682 : symbolic::pointer
683 32480 : region::calc_pointer (symbolic::node_manager &mgr) const
684 : {
685 32480 : const region *iter_region = this;
686 32480 : const region *base_region = nullptr;
687 :
688 32480 : auto &byte_mgr = mgr.get_scalars ().get_bytes ();
689 32480 : const symbolic::pointer::symbolic_byte_offset *accum_byte_offset
690 32480 : = &byte_mgr.get_concrete (0_bytes);
691 :
692 37425 : while (iter_region)
693 : {
694 37425 : switch (iter_region->get_kind ())
695 : {
696 3754 : case RK_FIELD:
697 3754 : case RK_ELEMENT:
698 3754 : case RK_OFFSET:
699 3754 : case RK_BIT_RANGE:
700 3754 : {
701 3754 : auto &rmm = mgr.get_region_model_manager ();
702 3754 : auto *byte_offset
703 3754 : = iter_region->maybe_get_byte_offset_relative_to_parent (rmm);
704 3754 : gcc_assert (byte_offset);
705 3754 : accum_byte_offset = &(*accum_byte_offset + *byte_offset);
706 3754 : iter_region = iter_region->get_parent_region ();
707 : }
708 3754 : continue;
709 :
710 1191 : case RK_SIZED:
711 1191 : case RK_CAST:
712 1191 : iter_region = iter_region->get_parent_region ();
713 1191 : continue;
714 :
715 5450 : case RK_SYMBOLIC:
716 5450 : {
717 5450 : const symbolic_region *sym_reg
718 5450 : = as_a<const symbolic_region *> (iter_region);
719 5450 : if (auto *sym_ptr = sym_reg->get_pointer ()->maybe_get_symbolic_pointer ())
720 : {
721 21 : base_region = &sym_ptr->get_base_region ();
722 21 : iter_region = nullptr;
723 21 : accum_byte_offset
724 21 : = &(*accum_byte_offset + sym_ptr->get_byte_offset ());
725 21 : break;
726 : }
727 : }
728 : /* Fall through. */
729 :
730 : default:
731 : base_region = iter_region;
732 : iter_region = nullptr;
733 : break;
734 4945 : }
735 : }
736 :
737 32480 : gcc_assert (base_region);
738 :
739 32480 : return symbolic::pointer (*base_region,
740 32480 : *accum_byte_offset);
741 : }
742 :
743 : const region::symbolic_bit_count *
744 0 : region::
745 : maybe_get_bit_offset_relative_to_parent (region_model_manager &) const
746 : {
747 0 : return nullptr;
748 : }
749 :
750 : const region::symbolic_byte_count *
751 0 : region::
752 : maybe_get_byte_offset_relative_to_parent (region_model_manager &) const
753 : {
754 0 : return nullptr;
755 : }
756 :
757 : DEBUG_FUNCTION void
758 0 : region::dump () const
759 : {
760 0 : symbolic::dump_node_tree_to_stderr<region> (*this);
761 0 : }
762 :
763 : bool
764 0 : region::maybe_print_for_user (pretty_printer *pp,
765 : const region_model &) const
766 : {
767 0 : switch (get_kind ())
768 : {
769 : default:
770 : break;
771 0 : case RK_DECL:
772 0 : {
773 0 : const decl_region *reg = (const decl_region *)this;
774 0 : tree decl = reg->get_decl ();
775 0 : if (TREE_CODE (decl) == SSA_NAME)
776 0 : decl = SSA_NAME_VAR (decl);
777 0 : print_expr_for_user (pp, decl);
778 0 : return true;
779 : }
780 : }
781 :
782 : return false;
783 : }
784 :
785 : void
786 4557 : region::add_dump_widget_children_for_region (text_art::tree_widget &,
787 : symbolic::node_dump_state &) const
788 : {
789 : // no-op
790 4557 : }
791 :
792 : /* Generate a description of this region. */
793 :
794 : DEBUG_FUNCTION label_text
795 28 : region::get_desc (bool simple) const
796 : {
797 28 : pretty_printer pp;
798 28 : pp_format_decoder (&pp) = default_tree_printer;
799 28 : dump_to_pp (&pp, simple);
800 28 : return label_text::take (xstrdup (pp_formatted_text (&pp)));
801 28 : }
802 :
803 : /* Base implementation of region::accept vfunc.
804 : Subclass implementations should chain up to this. */
805 :
806 : void
807 5097 : region::accept (visitor *v) const
808 : {
809 5097 : v->visit_region (this);
810 5097 : if (m_parent)
811 3720 : m_parent->accept (v);
812 5097 : }
813 :
814 : std::unique_ptr<json::object>
815 699 : region::make_json_obj (const char *type_name) const
816 : {
817 699 : auto obj = symbolic::node::make_json_obj (type_name);
818 699 : if (m_type)
819 99 : obj->set ("type", tree_to_json (m_type));
820 699 : if (m_parent)
821 477 : obj->set ("parent", m_parent->to_json ());
822 699 : return obj;
823 : }
824 :
825 : /* Return true if this is a symbolic region for dereferencing an
826 : unknown ptr.
827 : We shouldn't attempt to bind values for this region (but
828 : can unbind values for other regions). */
829 :
830 : bool
831 4228152 : region::symbolic_for_unknown_ptr_p () const
832 : {
833 4228152 : if (const symbolic_region *sym_reg = dyn_cast_symbolic_region ())
834 707746 : if (sym_reg->get_pointer ()->get_kind () == SK_UNKNOWN)
835 15045 : return true;
836 : return false;
837 : }
838 :
839 : /* Return true if this is a symbolic region. */
840 :
841 : bool
842 661201 : region::symbolic_p () const
843 : {
844 661201 : return get_kind () == RK_SYMBOLIC;
845 : }
846 :
847 : /* Return true if this region is known to be zero bits in size. */
848 :
849 : bool
850 2401672 : region::empty_p (region_model_manager &rmm) const
851 : {
852 2401672 : bit_size_t num_bits;
853 2401672 : auto &bit_mgr = rmm.get_node_manager ().get_scalars ().get_bits ();
854 2401672 : if (auto *size = maybe_get_bit_size (bit_mgr))
855 2400432 : if (size->is_zero_p ())
856 : return true;
857 : return false;
858 : }
859 :
860 : /* Return true if this is a region for a decl with name DECL_NAME.
861 : Intended for use when debugging (for assertions and conditional
862 : breakpoints). */
863 :
864 : DEBUG_FUNCTION bool
865 0 : region::is_named_decl_p (const char *decl_name) const
866 : {
867 0 : if (tree decl = maybe_get_decl ())
868 0 : if (DECL_NAME (decl)
869 0 : && !strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), decl_name))
870 0 : return true;
871 : return false;
872 : }
873 :
874 : /* region's ctor. */
875 :
876 255923 : region::region (complexity c, symbolic::node::id_t id, const region *parent, tree type)
877 : : symbolic::node (c, id),
878 255923 : m_parent (parent), m_type (type),
879 255923 : m_cached_memory_range (nullptr),
880 255923 : m_cached_init_sval_at_main (nullptr)
881 : {
882 255923 : gcc_assert (type == NULL_TREE || TYPE_P (type));
883 255923 : }
884 :
885 : /* Comparator for use by vec<const region *>::qsort,
886 : using their IDs to order them. */
887 :
888 : int
889 14671924 : region::cmp_ptr_ptr (const void *p1, const void *p2)
890 : {
891 14671924 : const region * const *reg1 = (const region * const *)p1;
892 14671924 : const region * const *reg2 = (const region * const *)p2;
893 :
894 14671924 : return cmp_ids (*reg1, *reg2);
895 : }
896 :
897 : /* Determine if a pointer to this region must be non-NULL.
898 :
899 : Generally, pointers to regions must be non-NULL, but pointers
900 : to symbolic_regions might, in fact, be NULL.
901 :
902 : This allows us to simulate functions like malloc and calloc with:
903 : - only one "outcome" from each statement,
904 : - the idea that the pointer is on the heap if non-NULL
905 : - the possibility that the pointer could be NULL
906 : - the idea that successive values returned from malloc are non-equal
907 : - to be able to zero-fill for calloc. */
908 :
909 : bool
910 9141 : region::non_null_p () const
911 : {
912 9141 : switch (get_kind ())
913 : {
914 : default:
915 : return true;
916 : case RK_SYMBOLIC:
917 : /* Are we within a symbolic_region? If so, it could be NULL, and we
918 : have to fall back on the constraints. */
919 : return false;
920 : case RK_HEAP_ALLOCATED:
921 : return false;
922 : }
923 : }
924 :
925 : /* Comparator for trees to impose a deterministic ordering on
926 : T1 and T2. */
927 :
928 : static int
929 73560 : tree_cmp (const_tree t1, const_tree t2)
930 : {
931 73560 : gcc_assert (t1);
932 73560 : gcc_assert (t2);
933 :
934 : /* Test tree codes first. */
935 73560 : if (TREE_CODE (t1) != TREE_CODE (t2))
936 31744 : return TREE_CODE (t1) - TREE_CODE (t2);
937 :
938 : /* From this point on, we know T1 and T2 have the same tree code. */
939 :
940 41816 : if (DECL_P (t1))
941 : {
942 0 : if (DECL_NAME (t1) && DECL_NAME (t2))
943 0 : return strcmp (IDENTIFIER_POINTER (DECL_NAME (t1)),
944 0 : IDENTIFIER_POINTER (DECL_NAME (t2)));
945 : else
946 : {
947 0 : if (DECL_NAME (t1))
948 : return -1;
949 0 : else if (DECL_NAME (t2))
950 : return 1;
951 : else
952 0 : return DECL_UID (t1) - DECL_UID (t2);
953 : }
954 : }
955 :
956 41816 : switch (TREE_CODE (t1))
957 : {
958 0 : case SSA_NAME:
959 0 : {
960 0 : if (SSA_NAME_VAR (t1) && SSA_NAME_VAR (t2))
961 : {
962 0 : int var_cmp = tree_cmp (SSA_NAME_VAR (t1), SSA_NAME_VAR (t2));
963 0 : if (var_cmp)
964 : return var_cmp;
965 0 : return SSA_NAME_VERSION (t1) - SSA_NAME_VERSION (t2);
966 : }
967 : else
968 : {
969 0 : if (SSA_NAME_VAR (t1))
970 : return -1;
971 0 : else if (SSA_NAME_VAR (t2))
972 : return 1;
973 : else
974 0 : return SSA_NAME_VERSION (t1) - SSA_NAME_VERSION (t2);
975 : }
976 : }
977 8384 : break;
978 :
979 8384 : case INTEGER_CST:
980 8384 : return tree_int_cst_compare (t1, t2);
981 :
982 33432 : case REAL_CST:
983 33432 : {
984 33432 : const real_value *rv1 = TREE_REAL_CST_PTR (t1);
985 33432 : const real_value *rv2 = TREE_REAL_CST_PTR (t2);
986 33432 : if (real_compare (UNORDERED_EXPR, rv1, rv2))
987 : {
988 : /* Impose an arbitrary order on NaNs relative to other NaNs
989 : and to non-NaNs. */
990 25040 : if (int cmp_isnan = real_isnan (rv1) - real_isnan (rv2))
991 : return cmp_isnan;
992 16800 : if (int cmp_issignaling_nan
993 8400 : = real_issignaling_nan (rv1) - real_issignaling_nan (rv2))
994 : return cmp_issignaling_nan;
995 4016 : return real_isneg (rv1) - real_isneg (rv2);
996 : }
997 8392 : if (real_compare (LT_EXPR, rv1, rv2))
998 : return -1;
999 5008 : if (real_compare (GT_EXPR, rv1, rv2))
1000 2292 : return 1;
1001 : return 0;
1002 : }
1003 :
1004 0 : case STRING_CST:
1005 0 : return strcmp (TREE_STRING_POINTER (t1),
1006 0 : TREE_STRING_POINTER (t2));
1007 :
1008 0 : default:
1009 0 : gcc_unreachable ();
1010 : break;
1011 : }
1012 :
1013 : gcc_unreachable ();
1014 :
1015 : return 0;
1016 : }
1017 :
1018 : /* qsort comparator for trees to impose a deterministic ordering on
1019 : P1 and P2. */
1020 :
1021 : int
1022 73560 : tree_cmp (const void *p1, const void *p2)
1023 : {
1024 73560 : const_tree t1 = *(const_tree const *)p1;
1025 73560 : const_tree t2 = *(const_tree const *)p2;
1026 :
1027 73560 : return tree_cmp (t1, t2);
1028 : }
1029 :
1030 : /* class frame_region : public space_region. */
1031 :
1032 37624 : frame_region::~frame_region ()
1033 : {
1034 140288 : for (map_t::iterator iter = m_locals.begin ();
1035 140288 : iter != m_locals.end ();
1036 121476 : ++iter)
1037 121476 : delete (*iter).second;
1038 37624 : }
1039 :
1040 : void
1041 966 : frame_region::accept (visitor *v) const
1042 : {
1043 966 : region::accept (v);
1044 966 : if (m_calling_frame)
1045 : m_calling_frame->accept (v);
1046 966 : }
1047 :
1048 : /* Implementation of region::dump_to_pp vfunc for frame_region. */
1049 :
1050 : void
1051 1280 : frame_region::dump_to_pp (pretty_printer *pp, bool simple) const
1052 : {
1053 1280 : if (simple)
1054 1273 : pp_printf (pp, "frame: %qs@%i", function_name (&m_fun), get_stack_depth ());
1055 : else
1056 7 : pp_printf (pp, "frame_region(%qs, index: %i, depth: %i)",
1057 7 : function_name (&m_fun), m_index, get_stack_depth ());
1058 1280 : }
1059 :
1060 : void
1061 0 : frame_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1062 : {
1063 0 : pp_printf (pp, "frame_region(%qs, index: %i, depth: %i)",
1064 0 : function_name (&m_fun), m_index, get_stack_depth ());
1065 0 : }
1066 :
1067 : void
1068 18157374 : frame_region::accept_node_visitor (symbolic::node_visitor &v) const
1069 : {
1070 18157374 : if (v.visit_region (*this))
1071 18157374 : get_parent_region ()->accept_node_visitor (v);
1072 18157374 : }
1073 :
1074 : std::unique_ptr<json::object>
1075 65 : frame_region::to_json () const
1076 : {
1077 65 : auto obj = region::make_json_obj ("frame_region");
1078 65 : obj->set_string ("function", function_name (&m_fun));
1079 65 : obj->set_integer ("index", m_index);
1080 65 : obj->set_integer ("stack_depth", get_stack_depth ());
1081 65 : return obj;
1082 : }
1083 :
1084 : std::unique_ptr<diagnostics::markup::node>
1085 0 : frame_region::make_markup_node (symbolic::markup_context &) const
1086 : {
1087 0 : return diagnostics::markup::make_text_node ("frame_region");
1088 : }
1089 :
1090 : const decl_region *
1091 1206524 : frame_region::get_region_for_local (region_model_manager *mgr,
1092 : tree expr,
1093 : const region_model_context *ctxt) const
1094 : {
1095 1206524 : if (CHECKING_P)
1096 : {
1097 : /* Verify that EXPR is a local or SSA name, and that it's for the
1098 : correct function for this stack frame. */
1099 1206524 : gcc_assert (TREE_CODE (expr) == PARM_DECL
1100 : || TREE_CODE (expr) == VAR_DECL
1101 : || TREE_CODE (expr) == SSA_NAME
1102 : || TREE_CODE (expr) == RESULT_DECL);
1103 1206524 : switch (TREE_CODE (expr))
1104 : {
1105 : default:
1106 : gcc_unreachable ();
1107 84920 : case VAR_DECL:
1108 84920 : gcc_assert (!is_global_var (expr));
1109 : /* Fall through. */
1110 119314 : case PARM_DECL:
1111 119314 : case RESULT_DECL:
1112 119314 : gcc_assert (DECL_CONTEXT (expr) == m_fun.decl);
1113 : break;
1114 1087210 : case SSA_NAME:
1115 1087210 : {
1116 1087210 : if (tree var = SSA_NAME_VAR (expr))
1117 : {
1118 559131 : if (DECL_P (var))
1119 559131 : gcc_assert (DECL_CONTEXT (var) == m_fun.decl);
1120 : }
1121 528079 : else if (ctxt)
1122 303676 : if (const extrinsic_state *ext_state = ctxt->get_ext_state ())
1123 289258 : if (const supergraph *sg
1124 289258 : = ext_state->get_engine ()->get_supergraph ())
1125 : {
1126 289258 : const gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
1127 289258 : if (gimple_code (def_stmt) != GIMPLE_PHI)
1128 : {
1129 283265 : const supernode *snode
1130 283265 : = sg->get_supernode_for_stmt (def_stmt);
1131 283265 : gcc_assert (snode->get_function () == &m_fun);
1132 : }
1133 : }
1134 : }
1135 : break;
1136 : }
1137 : }
1138 :
1139 : /* Ideally we'd use mutable here. */
1140 1206524 : map_t &mutable_locals = const_cast <map_t &> (m_locals);
1141 :
1142 1206524 : if (decl_region **slot = mutable_locals.get (expr))
1143 1085048 : return *slot;
1144 121476 : decl_region *reg
1145 121476 : = new decl_region (mgr->alloc_node_id (), this, expr);
1146 121476 : mutable_locals.put (expr, reg);
1147 121476 : return reg;
1148 : }
1149 :
1150 : /* class globals_region : public space_region. */
1151 :
1152 : /* Implementation of region::dump_to_pp vfunc for globals_region. */
1153 :
1154 : void
1155 464 : globals_region::dump_to_pp (pretty_printer *pp, bool simple) const
1156 : {
1157 464 : if (simple)
1158 464 : pp_string (pp, "::");
1159 : else
1160 0 : pp_string (pp, "globals");
1161 464 : }
1162 :
1163 : void
1164 1519 : globals_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1165 : {
1166 1519 : pp_string (pp, "globals");
1167 1519 : }
1168 :
1169 : void
1170 6426734 : globals_region::accept_node_visitor (symbolic::node_visitor &v) const
1171 : {
1172 6426734 : if (v.visit_region (*this))
1173 6426734 : get_parent_region ()->accept_node_visitor (v);
1174 6426734 : }
1175 :
1176 : std::unique_ptr<json::object>
1177 38 : globals_region::to_json () const
1178 : {
1179 38 : return region::make_json_obj ("globals_region");
1180 : }
1181 :
1182 : std::unique_ptr<diagnostics::markup::node>
1183 0 : globals_region::make_markup_node (symbolic::markup_context &) const
1184 : {
1185 0 : return diagnostics::markup::make_text_node ("globals_region");
1186 : }
1187 :
1188 : /* class code_region : public map_region. */
1189 :
1190 : /* Implementation of region::dump_to_pp vfunc for code_region. */
1191 :
1192 : void
1193 0 : code_region::dump_to_pp (pretty_printer *pp, bool simple) const
1194 : {
1195 0 : if (simple)
1196 0 : pp_string (pp, "code region");
1197 : else
1198 0 : pp_string (pp, "code_region()");
1199 0 : }
1200 :
1201 : void
1202 0 : code_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1203 : {
1204 0 : pp_string (pp, "code region");
1205 0 : }
1206 :
1207 : void
1208 39893 : code_region::accept_node_visitor (symbolic::node_visitor &v) const
1209 : {
1210 39893 : if (v.visit_region (*this))
1211 39893 : get_parent_region ()->accept_node_visitor (v);
1212 39893 : }
1213 :
1214 : std::unique_ptr<json::object>
1215 0 : code_region::to_json () const
1216 : {
1217 0 : return region::make_json_obj ("code_region");
1218 : }
1219 :
1220 : std::unique_ptr<diagnostics::markup::node>
1221 0 : code_region::make_markup_node (symbolic::markup_context &) const
1222 : {
1223 0 : return diagnostics::markup::make_text_node ("code_region");
1224 : }
1225 :
1226 : /* class function_region : public region. */
1227 :
1228 : /* Implementation of region::dump_to_pp vfunc for function_region. */
1229 :
1230 : void
1231 413 : function_region::dump_to_pp (pretty_printer *pp, bool simple) const
1232 : {
1233 413 : if (simple)
1234 : {
1235 413 : dump_quoted_tree (pp, m_fndecl);
1236 : }
1237 : else
1238 : {
1239 0 : pp_string (pp, "function_region(");
1240 0 : dump_quoted_tree (pp, m_fndecl);
1241 0 : pp_string (pp, ")");
1242 : }
1243 413 : }
1244 :
1245 : void
1246 0 : function_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1247 : {
1248 0 : pp_string (pp, "function_region(");
1249 0 : dump_quoted_tree (pp, m_fndecl);
1250 0 : pp_string (pp, ")");
1251 0 : }
1252 :
1253 : void
1254 39893 : function_region::accept_node_visitor (symbolic::node_visitor &v) const
1255 : {
1256 39893 : if (v.visit_region (*this))
1257 39893 : get_parent_region ()->accept_node_visitor (v);
1258 39893 : }
1259 :
1260 : std::unique_ptr<json::object>
1261 0 : function_region::to_json () const
1262 : {
1263 0 : auto obj = region::make_json_obj ("function_region");
1264 0 : obj->set ("fndecl", tree_to_json (m_fndecl));
1265 0 : return obj;
1266 : }
1267 :
1268 : std::unique_ptr<diagnostics::markup::node>
1269 0 : function_region::make_markup_node (symbolic::markup_context &) const
1270 : {
1271 0 : return diagnostics::markup::make_text_node ("function_region");
1272 : }
1273 :
1274 : /* class label_region : public region. */
1275 :
1276 : /* Implementation of region::dump_to_pp vfunc for label_region. */
1277 :
1278 : void
1279 0 : label_region::dump_to_pp (pretty_printer *pp, bool simple) const
1280 : {
1281 0 : if (simple)
1282 : {
1283 0 : dump_quoted_tree (pp, m_label);
1284 : }
1285 : else
1286 : {
1287 0 : pp_string (pp, "label_region(");
1288 0 : dump_quoted_tree (pp, m_label);
1289 0 : pp_string (pp, ")");
1290 : }
1291 0 : }
1292 :
1293 : void
1294 0 : label_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1295 : {
1296 0 : pp_string (pp, "label_region(");
1297 0 : dump_quoted_tree (pp, m_label);
1298 0 : pp_string (pp, ")");
1299 0 : }
1300 :
1301 : void
1302 5384 : label_region::accept_node_visitor (symbolic::node_visitor &v) const
1303 : {
1304 5384 : if (v.visit_region (*this))
1305 5384 : get_parent_region ()->accept_node_visitor (v);
1306 5384 : }
1307 :
1308 : std::unique_ptr<json::object>
1309 0 : label_region::to_json () const
1310 : {
1311 0 : auto obj = region::make_json_obj ("label_region");
1312 0 : obj->set ("label", tree_to_json (m_label));
1313 0 : return obj;
1314 : }
1315 :
1316 : std::unique_ptr<diagnostics::markup::node>
1317 0 : label_region::make_markup_node (symbolic::markup_context &) const
1318 : {
1319 0 : return diagnostics::markup::make_text_node ("label_region");
1320 : }
1321 :
1322 : /* class stack_region : public region. */
1323 :
1324 : /* Implementation of region::dump_to_pp vfunc for stack_region. */
1325 :
1326 : void
1327 0 : stack_region::dump_to_pp (pretty_printer *pp, bool simple) const
1328 : {
1329 0 : if (simple)
1330 0 : pp_string (pp, "stack region");
1331 : else
1332 0 : pp_string (pp, "stack_region()");
1333 0 : }
1334 :
1335 : void
1336 0 : stack_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1337 : {
1338 0 : pp_string (pp, "stack region");
1339 0 : }
1340 :
1341 : void
1342 18157374 : stack_region::accept_node_visitor (symbolic::node_visitor &v) const
1343 : {
1344 18157374 : if (v.visit_region (*this))
1345 18157374 : get_parent_region ()->accept_node_visitor (v);
1346 18157374 : }
1347 :
1348 : std::unique_ptr<json::object>
1349 65 : stack_region::to_json () const
1350 : {
1351 65 : return region::make_json_obj ("stack_region");
1352 : }
1353 :
1354 : std::unique_ptr<diagnostics::markup::node>
1355 0 : stack_region::make_markup_node (symbolic::markup_context &) const
1356 : {
1357 0 : return diagnostics::markup::make_text_node ("stack_region");
1358 : }
1359 :
1360 : /* class heap_region : public region. */
1361 :
1362 : /* Implementation of region::dump_to_pp vfunc for heap_region. */
1363 :
1364 : void
1365 0 : heap_region::dump_to_pp (pretty_printer *pp, bool simple) const
1366 : {
1367 0 : if (simple)
1368 0 : pp_string (pp, "heap region");
1369 : else
1370 0 : pp_string (pp, "heap_region()");
1371 0 : }
1372 :
1373 : void
1374 0 : heap_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1375 : {
1376 0 : pp_string (pp, "heap_region");
1377 0 : }
1378 :
1379 : void
1380 0 : heap_region::accept_node_visitor (symbolic::node_visitor &v) const
1381 : {
1382 0 : if (v.visit_region (*this))
1383 0 : get_parent_region ()->accept_node_visitor (v);
1384 0 : }
1385 :
1386 : std::unique_ptr<json::object>
1387 105 : heap_region::to_json () const
1388 : {
1389 105 : return region::make_json_obj ("heap_region");
1390 : }
1391 :
1392 : std::unique_ptr<diagnostics::markup::node>
1393 0 : heap_region::make_markup_node (symbolic::markup_context &) const
1394 : {
1395 0 : return diagnostics::markup::make_text_node ("heap_region");
1396 : }
1397 :
1398 : /* class root_region : public region. */
1399 :
1400 : /* root_region's ctor. */
1401 :
1402 4409 : root_region::root_region (symbolic::node::id_t id)
1403 4409 : : region (complexity (1, 1), id, nullptr, NULL_TREE)
1404 : {
1405 4409 : }
1406 :
1407 : /* Implementation of region::dump_to_pp vfunc for root_region. */
1408 :
1409 : void
1410 58 : root_region::dump_to_pp (pretty_printer *pp, bool simple) const
1411 : {
1412 58 : if (simple)
1413 58 : pp_string (pp, "root region");
1414 : else
1415 0 : pp_string (pp, "root_region()");
1416 58 : }
1417 :
1418 : void
1419 1618 : root_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1420 : {
1421 1618 : pp_string (pp, "root region");
1422 1618 : }
1423 :
1424 : void
1425 28790019 : root_region::accept_node_visitor (symbolic::node_visitor &v) const
1426 : {
1427 28790019 : v.visit_region (*this);
1428 28790019 : }
1429 :
1430 : std::unique_ptr<json::object>
1431 222 : root_region::to_json () const
1432 : {
1433 222 : return region::make_json_obj ("root_region");
1434 : }
1435 :
1436 : std::unique_ptr<diagnostics::markup::node>
1437 0 : root_region::make_markup_node (symbolic::markup_context &) const
1438 : {
1439 0 : return diagnostics::markup::make_text_node ("root_region");
1440 : }
1441 :
1442 : /* class thread_local_region : public space_region. */
1443 :
1444 : void
1445 0 : thread_local_region::dump_to_pp (pretty_printer *pp, bool simple) const
1446 : {
1447 0 : if (simple)
1448 0 : pp_string (pp, "thread_local_region");
1449 : else
1450 0 : pp_string (pp, "thread_local_region()");
1451 0 : }
1452 :
1453 : void
1454 0 : thread_local_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1455 : {
1456 0 : pp_string (pp, "thread_local_region");
1457 0 : }
1458 :
1459 : void
1460 115776 : thread_local_region::accept_node_visitor (symbolic::node_visitor &v) const
1461 : {
1462 115776 : if (v.visit_region (*this))
1463 115776 : get_parent_region ()->accept_node_visitor (v);
1464 115776 : }
1465 :
1466 : std::unique_ptr<json::object>
1467 0 : thread_local_region::to_json () const
1468 : {
1469 0 : return region::make_json_obj ("thread_local_region");
1470 : }
1471 :
1472 : std::unique_ptr<diagnostics::markup::node>
1473 0 : thread_local_region::make_markup_node (symbolic::markup_context &) const
1474 : {
1475 0 : return diagnostics::markup::make_text_node ("thread_local_region");
1476 : }
1477 :
1478 : /* class symbolic_region : public map_region. */
1479 :
1480 : /* symbolic_region's ctor. */
1481 :
1482 9928 : symbolic_region::symbolic_region (symbolic::node::id_t id, region *parent,
1483 : const svalue *sval_ptr)
1484 9928 : : region (complexity::from_pair (parent, sval_ptr), id, parent,
1485 9928 : (sval_ptr->get_type ()
1486 9902 : ? TREE_TYPE (sval_ptr->get_type ())
1487 : : NULL_TREE)),
1488 29758 : m_sval_ptr (sval_ptr)
1489 : {
1490 9928 : }
1491 :
1492 : /* Implementation of region::accept vfunc for symbolic_region. */
1493 :
1494 : void
1495 0 : symbolic_region::accept (visitor *v) const
1496 : {
1497 0 : region::accept (v);
1498 0 : m_sval_ptr->accept (v);
1499 0 : }
1500 :
1501 : /* Implementation of region::dump_to_pp vfunc for symbolic_region. */
1502 :
1503 : void
1504 68 : symbolic_region::dump_to_pp (pretty_printer *pp, bool simple) const
1505 : {
1506 68 : if (simple)
1507 : {
1508 68 : pp_string (pp, "(*");
1509 68 : m_sval_ptr->dump_to_pp (pp, simple);
1510 68 : pp_string (pp, ")");
1511 : }
1512 : else
1513 : {
1514 0 : pp_string (pp, "symbolic_region(");
1515 0 : get_parent_region ()->dump_to_pp (pp, simple);
1516 0 : if (get_type ())
1517 : {
1518 0 : pp_string (pp, ", ");
1519 0 : print_quoted_type (pp, get_type ());
1520 : }
1521 0 : pp_string (pp, ", ");
1522 0 : m_sval_ptr->dump_to_pp (pp, simple);
1523 0 : pp_string (pp, ")");
1524 : }
1525 68 : }
1526 :
1527 : void
1528 99 : symbolic_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1529 : {
1530 99 : pp_string (pp, "symbolic_region: %<*%>");
1531 99 : }
1532 :
1533 : void
1534 99 : symbolic_region::
1535 : add_dump_widget_children_for_region (text_art::tree_widget &w,
1536 : symbolic::node_dump_state &nds) const
1537 : {
1538 198 : w.add_child (m_sval_ptr->make_dump_widget (nds, "m_sval_ptr"));
1539 99 : }
1540 :
1541 : void
1542 3808339 : symbolic_region::accept_node_visitor (symbolic::node_visitor &v) const
1543 : {
1544 3808339 : if (v.visit_region (*this))
1545 : {
1546 3808339 : get_parent_region ()->accept_node_visitor (v);
1547 3808339 : m_sval_ptr->accept_node_visitor (v);
1548 : }
1549 3808339 : }
1550 :
1551 : std::unique_ptr<json::object>
1552 14 : symbolic_region::to_json () const
1553 : {
1554 14 : auto obj = region::make_json_obj ("symbolic_region");
1555 14 : obj->set ("sval_ptr", m_sval_ptr->to_json ());
1556 14 : return obj;
1557 : }
1558 :
1559 : std::unique_ptr<diagnostics::markup::node>
1560 0 : symbolic_region::make_markup_node (symbolic::markup_context &) const
1561 : {
1562 0 : return diagnostics::markup::make_text_node ("symbolic_region");
1563 : }
1564 :
1565 : /* class decl_region : public region. */
1566 :
1567 : /* Implementation of region::dump_to_pp vfunc for decl_region. */
1568 :
1569 : void
1570 3171 : decl_region::dump_to_pp (pretty_printer *pp, bool simple) const
1571 : {
1572 3171 : if (simple)
1573 3164 : pp_printf (pp, "%E", m_decl);
1574 : else
1575 : {
1576 7 : pp_string (pp, "decl_region(");
1577 7 : get_parent_region ()->dump_to_pp (pp, simple);
1578 7 : pp_string (pp, ", ");
1579 7 : print_quoted_type (pp, get_type ());
1580 7 : pp_printf (pp, ", %qE)", m_decl);
1581 : }
1582 3171 : }
1583 :
1584 : void
1585 2019 : decl_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1586 : {
1587 2019 : pp_printf (pp, "decl_region(%qE)", m_decl);
1588 2019 : }
1589 :
1590 : void
1591 24536321 : decl_region::accept_node_visitor (symbolic::node_visitor &v) const
1592 : {
1593 24536321 : if (v.visit_region (*this))
1594 24536321 : get_parent_region ()->accept_node_visitor (v);
1595 24536321 : }
1596 :
1597 : std::unique_ptr<json::object>
1598 85 : decl_region::to_json () const
1599 : {
1600 85 : auto obj = region::make_json_obj ("decl_region");
1601 85 : obj->set ("decl", tree_to_json (m_decl));
1602 85 : return obj;
1603 : }
1604 :
1605 : std::unique_ptr<diagnostics::markup::node>
1606 74 : decl_region::make_markup_node (symbolic::markup_context &markup_ctxt) const
1607 : {
1608 74 : tree decl = m_decl;
1609 74 : if (markup_ctxt.m_user_facing)
1610 74 : if (TREE_CODE (decl) == SSA_NAME)
1611 38 : decl = SSA_NAME_VAR (decl);
1612 :
1613 74 : pretty_printer pp;
1614 74 : pp_format_decoder (&pp) = default_tree_printer;
1615 74 : print_expr_for_user (&pp, decl);
1616 74 : return diagnostics::markup::make_text_node (pp_formatted_text (&pp));
1617 74 : }
1618 :
1619 : /* Get the stack depth for the frame containing this decl, or 0
1620 : for a global. */
1621 :
1622 : int
1623 10399 : decl_region::get_stack_depth () const
1624 : {
1625 10399 : if (get_parent_region () == nullptr)
1626 : return 0;
1627 20798 : if (const frame_region *frame_reg
1628 10399 : = get_parent_region ()->dyn_cast_frame_region ())
1629 9945 : return frame_reg->get_stack_depth ();
1630 : return 0;
1631 : }
1632 :
1633 : /* If the underlying decl is in the global constant pool,
1634 : return an svalue representing the constant value.
1635 : Otherwise return nullptr. */
1636 :
1637 : const svalue *
1638 2051639 : decl_region::maybe_get_constant_value (region_model_manager *mgr) const
1639 : {
1640 2051639 : if (VAR_P (m_decl)
1641 130569 : && DECL_IN_CONSTANT_POOL (m_decl)
1642 16 : && DECL_INITIAL (m_decl)
1643 2051655 : && TREE_CODE (DECL_INITIAL (m_decl)) == CONSTRUCTOR)
1644 16 : return get_svalue_for_constructor (DECL_INITIAL (m_decl), mgr);
1645 : return nullptr;
1646 : }
1647 :
1648 : /* Get an svalue for CTOR, a CONSTRUCTOR for this region's decl. */
1649 : const svalue *
1650 16 : decl_region::get_svalue_for_constructor (tree ctor,
1651 : region_model_manager *mgr) const
1652 : {
1653 16 : auto &bit_contents = get_bit_contents_for_constructor (ctor, mgr);
1654 16 : auto mem_range = get_memory_range (*mgr);
1655 16 : auto &bv = bit_contents.get_bits (mem_range.get_bit_range ());
1656 16 : return mgr->get_svalue_from_bit_vector (get_type (), bv);
1657 : }
1658 :
1659 : /* Get the contents for CTOR, a CONSTRUCTOR for this region's decl. */
1660 :
1661 : const symbolic::bit_contents &
1662 167 : decl_region::get_bit_contents_for_constructor (tree ctor,
1663 : region_model_manager *mgr) const
1664 : {
1665 167 : gcc_assert (!TREE_CLOBBER_P (ctor));
1666 167 : gcc_assert (ctor == DECL_INITIAL (m_decl));
1667 :
1668 167 : if (!m_ctor_bit_contents)
1669 155 : m_ctor_bit_contents = &calc_bit_contents_for_constructor (ctor, mgr);
1670 :
1671 167 : return *m_ctor_bit_contents;
1672 : }
1673 :
1674 : /* For use on decl_regions for global variables.
1675 :
1676 : Get an svalue for the initial value of this region at entry to
1677 : "main" (either based on DECL_INITIAL, or implicit initialization to
1678 : zero.
1679 :
1680 : Return nullptr if there is a problem. */
1681 :
1682 : const svalue *
1683 590 : decl_region::get_svalue_for_initializer (region_model_manager *mgr) const
1684 : {
1685 590 : if (!VAR_P (m_decl))
1686 : return nullptr;
1687 70 : tree init = DECL_INITIAL (m_decl);
1688 70 : if (!init)
1689 : {
1690 : /* If we have an "extern" decl then there may be an initializer in
1691 : another TU. */
1692 33 : if (DECL_EXTERNAL (m_decl))
1693 : return nullptr;
1694 :
1695 0 : if (empty_p (*mgr))
1696 : return nullptr;
1697 :
1698 0 : if (!tracked_p ())
1699 : return nullptr;
1700 :
1701 : /* Implicit initialization to zero.
1702 : Doing so requires that we have a concrete size for this region,
1703 : which can fail if we have a region with unknown size
1704 : (e.g. "extern const char arr[];"). */
1705 0 : auto &bit_mgr = mgr->get_node_manager ().get_scalars ().get_bits ();
1706 0 : auto *bit_size = maybe_get_bit_size (bit_mgr);
1707 0 : if (!bit_size)
1708 : return nullptr;
1709 0 : auto &bv_mgr = mgr->get_node_manager ().get_bit_vector_manager ();
1710 0 : auto &bv = bv_mgr.get_all_zeros (*bit_size);
1711 0 : return mgr->get_svalue_from_bit_vector (get_type (), bv);
1712 : }
1713 :
1714 : /* LTO can write out error_mark_node as the DECL_INITIAL for simple scalar
1715 : values (to avoid writing out an extra section). */
1716 37 : if (init == error_mark_node)
1717 : return nullptr;
1718 :
1719 33 : if (TREE_CODE (init) == CONSTRUCTOR)
1720 0 : return get_svalue_for_constructor (init, mgr);
1721 :
1722 : /* Reuse the get_rvalue logic from region_model. */
1723 33 : region_model m (mgr->get_node_manager ());
1724 33 : return m.get_rvalue (path_var (init, 0), nullptr);
1725 33 : }
1726 :
1727 : const symbolic::bit_contents *
1728 789 : decl_region::
1729 : maybe_get_bit_contents_for_initializer (region_model_manager *mgr) const
1730 : {
1731 789 : if (!VAR_P (m_decl))
1732 : return nullptr;
1733 269 : tree init = DECL_INITIAL (m_decl);
1734 269 : if (!init)
1735 : {
1736 : /* If we have an "extern" decl then there may be an initializer in
1737 : another TU. */
1738 81 : if (DECL_EXTERNAL (m_decl))
1739 : return nullptr;
1740 :
1741 47 : if (empty_p (*mgr))
1742 : return nullptr;
1743 :
1744 47 : if (!tracked_p ())
1745 : return nullptr;
1746 :
1747 : /* Implicit initialization to zero. */
1748 47 : auto &node_mgr = mgr->get_node_manager ();
1749 47 : auto &bit_contents_mgr = node_mgr.get_bit_contents_manager ();
1750 47 : return &bit_contents_mgr.get_all_zeros ();
1751 : }
1752 :
1753 : /* LTO can write out error_mark_node as the DECL_INITIAL for simple scalar
1754 : values (to avoid writing out an extra section). */
1755 188 : if (init == error_mark_node)
1756 : return nullptr;
1757 :
1758 184 : if (TREE_CODE (init) == CONSTRUCTOR)
1759 151 : return &get_bit_contents_for_constructor (init, mgr);
1760 :
1761 : return nullptr;
1762 : }
1763 :
1764 : /* Subroutine of symnode_requires_tracking_p; return true if REF
1765 : might imply that we should be tracking the value of its decl. */
1766 :
1767 : static bool
1768 4175 : ipa_ref_requires_tracking (ipa_ref *ref)
1769 : {
1770 : /* If we have a load/store/alias of the symbol, then we'll track
1771 : the decl's value. */
1772 4175 : if (ref->use != IPA_REF_ADDR)
1773 : return true;
1774 :
1775 4144 : if (ref->stmt == nullptr)
1776 : return true;
1777 :
1778 4144 : switch (ref->stmt->code)
1779 : {
1780 : default:
1781 : return true;
1782 4109 : case GIMPLE_CALL:
1783 4109 : {
1784 4109 : cgraph_node *caller_cnode = dyn_cast <cgraph_node *> (ref->referring);
1785 4109 : if (caller_cnode == nullptr)
1786 : return true;
1787 4109 : cgraph_edge *edge = caller_cnode->get_edge (ref->stmt);
1788 4109 : if (!edge)
1789 : return true;
1790 4109 : if (edge->callee == nullptr)
1791 : return true; /* e.g. call through function ptr. */
1792 4108 : if (edge->callee->definition)
1793 1 : return true;
1794 : /* If we get here, then this ref is a pointer passed to
1795 : a function we don't have the definition for. */
1796 : return false;
1797 : }
1798 17 : break;
1799 17 : case GIMPLE_ASM:
1800 17 : {
1801 17 : const gasm *asm_stmt = as_a <const gasm *> (ref->stmt);
1802 17 : if (gimple_asm_noutputs (asm_stmt) > 0)
1803 : return true;
1804 17 : if (gimple_asm_nclobbers (asm_stmt) > 0)
1805 0 : return true;
1806 : /* If we get here, then this ref is the decl being passed
1807 : by pointer to asm with no outputs. */
1808 : return false;
1809 : }
1810 : break;
1811 : }
1812 : }
1813 :
1814 : /* Determine if the decl for SYMNODE should have binding_clusters
1815 : in our state objects; return false to optimize away tracking
1816 : certain decls in our state objects, as an optimization. */
1817 :
1818 : static bool
1819 5806 : symnode_requires_tracking_p (symtab_node *symnode)
1820 : {
1821 5806 : gcc_assert (symnode);
1822 5806 : if (symnode->externally_visible)
1823 : return true;
1824 4734 : tree context_fndecl = DECL_CONTEXT (symnode->decl);
1825 4734 : if (context_fndecl == nullptr)
1826 : return true;
1827 4720 : if (TREE_CODE (context_fndecl) != FUNCTION_DECL)
1828 : return true;
1829 16520 : for (auto ref : symnode->ref_list.referring)
1830 4175 : if (ipa_ref_requires_tracking (ref))
1831 : return true;
1832 :
1833 : /* If we get here, then we don't have uses of this decl that require
1834 : tracking; we never read from it or write to it explicitly. */
1835 : return false;
1836 : }
1837 :
1838 : /* Subroutine of decl_region ctor: determine whether this decl_region
1839 : can have binding_clusters; return false to optimize away tracking
1840 : of certain decls in our state objects, as an optimization. */
1841 :
1842 : bool
1843 128186 : decl_region::calc_tracked_p (tree decl)
1844 : {
1845 : /* Precondition of symtab_node::get. */
1846 128186 : if (TREE_CODE (decl) == VAR_DECL
1847 128186 : && (TREE_STATIC (decl) || DECL_EXTERNAL (decl) || in_lto_p))
1848 6712 : if (symtab_node *symnode = symtab_node::get (decl))
1849 5806 : return symnode_requires_tracking_p (symnode);
1850 : return true;
1851 : }
1852 :
1853 : /* class field_region : public region. */
1854 :
1855 : /* Implementation of region::dump_to_pp vfunc for field_region. */
1856 :
1857 : void
1858 0 : field_region::dump_to_pp (pretty_printer *pp, bool simple) const
1859 : {
1860 0 : if (simple)
1861 : {
1862 0 : get_parent_region ()->dump_to_pp (pp, simple);
1863 0 : pp_string (pp, ".");
1864 0 : pp_printf (pp, "%E", m_field);
1865 : }
1866 : else
1867 : {
1868 0 : pp_string (pp, "field_region(");
1869 0 : get_parent_region ()->dump_to_pp (pp, simple);
1870 0 : pp_string (pp, ", ");
1871 0 : print_quoted_type (pp, get_type ());
1872 0 : pp_printf (pp, ", %qE)", m_field);
1873 : }
1874 0 : }
1875 :
1876 : void
1877 0 : field_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1878 : {
1879 0 : pp_printf (pp, "field_region(%qE)", m_field);
1880 0 : }
1881 :
1882 : void
1883 0 : field_region::accept_node_visitor (symbolic::node_visitor &v) const
1884 : {
1885 0 : if (v.visit_region (*this))
1886 0 : get_parent_region ()->accept_node_visitor (v);
1887 0 : }
1888 :
1889 : std::unique_ptr<json::object>
1890 0 : field_region::to_json () const
1891 : {
1892 0 : auto obj = region::make_json_obj ("field_region");
1893 0 : obj->set ("field", tree_to_json (m_field));
1894 0 : return obj;
1895 : }
1896 :
1897 : std::unique_ptr<diagnostics::markup::node>
1898 12 : field_region::make_markup_node (symbolic::markup_context &markup_ctxt) const
1899 : {
1900 12 : auto parent = get_parent_region ()->make_markup_node (markup_ctxt);
1901 :
1902 12 : const char *identifier = IDENTIFIER_POINTER (DECL_NAME (m_field));
1903 12 : auto field = diagnostics::markup::make_text_node (identifier);
1904 12 : return std::make_unique<diagnostics::markup::code::field_expr>
1905 12 : (std::move (parent),
1906 12 : std::move (field));
1907 12 : }
1908 :
1909 : const region::symbolic_bit_count *
1910 13764 : field_region::
1911 : maybe_get_bit_offset_relative_to_parent (region_model_manager &mgr) const
1912 : {
1913 13764 : auto &node_mgr = mgr.get_node_manager ();
1914 13764 : auto &bit_mgr = node_mgr.get_scalars ().get_bits ();
1915 : /* Compare with e.g. gimple-fold.cc's
1916 : fold_nonarray_ctor_reference. */
1917 13764 : tree byte_offset = DECL_FIELD_OFFSET (m_field);
1918 13764 : if (TREE_CODE (byte_offset) != INTEGER_CST)
1919 1 : return &bit_mgr.get_unknown ();
1920 13763 : tree field_offset = DECL_FIELD_BIT_OFFSET (m_field);
1921 : /* Compute bit offset of the field. */
1922 13763 : offset_int bitoffset
1923 13763 : = (wi::to_offset (field_offset)
1924 13763 : + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT));
1925 13763 : return &bit_mgr.get_concrete (convert_from_bit_offset_t (bitoffset));
1926 : }
1927 :
1928 : const region::symbolic_byte_count *
1929 2865 : field_region::
1930 : maybe_get_byte_offset_relative_to_parent (region_model_manager &mgr) const
1931 : {
1932 : /* Compare with e.g. gimple-fold.cc's
1933 : fold_nonarray_ctor_reference. */
1934 2865 : tree byte_offset = DECL_FIELD_OFFSET (m_field);
1935 2865 : if (TREE_CODE (byte_offset) != INTEGER_CST)
1936 : return nullptr;
1937 2865 : tree field_offset = DECL_FIELD_BIT_OFFSET (m_field);
1938 : /* Compute bit offset of the field. */
1939 2865 : offset_int bitoffset
1940 2865 : = (wi::to_offset (field_offset)
1941 2865 : + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT));
1942 :
1943 2865 : auto scalar_bits = convert_from_bit_offset_t (bitoffset);
1944 2865 : integer_with_unit<units::byte> scalar_bytes;
1945 2865 : if (!maybe_bytes_from_bits (scalar_bits, &scalar_bytes))
1946 : return nullptr;
1947 :
1948 2865 : auto &node_mgr = mgr.get_node_manager ();
1949 2865 : auto &byte_mgr = node_mgr.get_scalars ().get_bytes ();
1950 2865 : return &byte_mgr.get_concrete (scalar_bytes);
1951 2865 : }
1952 :
1953 : /* class element_region : public region. */
1954 :
1955 : /* Implementation of region::accept vfunc for element_region. */
1956 :
1957 : void
1958 0 : element_region::accept (visitor *v) const
1959 : {
1960 0 : region::accept (v);
1961 0 : m_index->accept (v);
1962 0 : }
1963 :
1964 : /* Implementation of region::dump_to_pp vfunc for element_region. */
1965 :
1966 : void
1967 4 : element_region::dump_to_pp (pretty_printer *pp, bool simple) const
1968 : {
1969 4 : if (simple)
1970 : {
1971 : //pp_string (pp, "(");
1972 4 : get_parent_region ()->dump_to_pp (pp, simple);
1973 4 : pp_string (pp, "[");
1974 4 : m_index->dump_to_pp (pp, simple);
1975 4 : pp_string (pp, "]");
1976 : //pp_string (pp, ")");
1977 : }
1978 : else
1979 : {
1980 0 : pp_string (pp, "element_region(");
1981 0 : get_parent_region ()->dump_to_pp (pp, simple);
1982 0 : pp_string (pp, ", ");
1983 0 : print_quoted_type (pp, get_type ());
1984 0 : pp_string (pp, ", ");
1985 0 : m_index->dump_to_pp (pp, simple);
1986 0 : pp_printf (pp, ")");
1987 : }
1988 4 : }
1989 :
1990 : void
1991 0 : element_region::print_region_for_dump_widget_label (pretty_printer *pp) const
1992 : {
1993 0 : pp_printf (pp, "element_region: %<[]%>");
1994 0 : }
1995 :
1996 : void
1997 0 : element_region::
1998 : add_dump_widget_children_for_region (text_art::tree_widget &w,
1999 : symbolic::node_dump_state &nds) const
2000 : {
2001 0 : w.add_child (m_index->make_dump_widget (nds, "m_index"));
2002 0 : }
2003 :
2004 : void
2005 1473 : element_region::accept_node_visitor (symbolic::node_visitor &v) const
2006 : {
2007 1473 : if (v.visit_region (*this))
2008 : {
2009 1473 : get_parent_region ()->accept_node_visitor (v);
2010 1473 : m_index->accept_node_visitor (v);
2011 : }
2012 1473 : }
2013 :
2014 : std::unique_ptr<json::object>
2015 0 : element_region::to_json () const
2016 : {
2017 0 : auto obj = region::make_json_obj ("element_region");
2018 0 : obj->set ("index", m_index->to_json ());
2019 0 : return obj;
2020 : }
2021 :
2022 : std::unique_ptr<diagnostics::markup::node>
2023 4 : element_region::make_markup_node (symbolic::markup_context &markup_ctxt) const
2024 : {
2025 4 : auto parent = get_parent_region ()->make_markup_node (markup_ctxt);
2026 4 : auto index = m_index->make_markup_node (markup_ctxt);
2027 4 : return std::make_unique<diagnostics::markup::code::element_expr>
2028 4 : (std::move (parent),
2029 4 : std::move (index));
2030 4 : }
2031 :
2032 : const region::symbolic_bit_count *
2033 6801 : element_region::
2034 : maybe_get_bit_offset_relative_to_parent (region_model_manager &mgr) const
2035 : {
2036 6801 : auto &node_mgr = mgr.get_node_manager ();
2037 6801 : auto &bit_mgr = node_mgr.get_scalars ().get_bits ();
2038 6801 : auto &unitless_mgr = node_mgr.get_scalars ().get_unitless ();
2039 :
2040 6801 : tree elem_type = get_type ();
2041 :
2042 : /* First, use int_size_in_bytes, to reject the case where we
2043 : have an incomplete type, or a non-constant value. */
2044 6801 : HOST_WIDE_INT hwi_byte_size = int_size_in_bytes (elem_type);
2045 6801 : if (hwi_byte_size > 0)
2046 : {
2047 6798 : auto &elem_size = bit_mgr.get_concrete
2048 6798 : (bits_from_bytes (convert_from_byte_size_t (hwi_byte_size)));
2049 6798 : auto &index = unitless_mgr.get_scalar_from_svalue (*m_index);
2050 6798 : return &(elem_size * index);
2051 : }
2052 :
2053 3 : return &bit_mgr.get_unknown ();
2054 : }
2055 :
2056 : const region::symbolic_byte_count *
2057 337 : element_region::
2058 : maybe_get_byte_offset_relative_to_parent (region_model_manager &mgr) const
2059 : {
2060 337 : auto &node_mgr = mgr.get_node_manager ();
2061 337 : auto &byte_mgr = node_mgr.get_scalars ().get_bytes ();
2062 337 : auto &unitless_mgr = node_mgr.get_scalars ().get_unitless ();
2063 :
2064 337 : tree elem_type = get_type ();
2065 :
2066 : /* First, use int_size_in_bytes, to reject the case where we
2067 : have an incomplete type, or a non-constant value. */
2068 337 : HOST_WIDE_INT hwi_byte_size = int_size_in_bytes (elem_type);
2069 :
2070 337 : if (hwi_byte_size > 0)
2071 : {
2072 335 : auto &elem_size
2073 335 : = byte_mgr.get_concrete (convert_from_byte_size_t (hwi_byte_size));
2074 335 : auto &index = unitless_mgr.get_scalar_from_svalue (*m_index);
2075 335 : return &(elem_size * index);
2076 : }
2077 :
2078 2 : return &byte_mgr.get_unknown ();
2079 : }
2080 :
2081 : /* class offset_region : public region. */
2082 :
2083 : /* Implementation of region::accept vfunc for offset_region. */
2084 :
2085 : void
2086 0 : offset_region::accept (visitor *v) const
2087 : {
2088 0 : region::accept (v);
2089 0 : m_byte_offset->accept (v);
2090 0 : }
2091 :
2092 : /* Implementation of region::dump_to_pp vfunc for offset_region. */
2093 :
2094 : void
2095 20 : offset_region::dump_to_pp (pretty_printer *pp, bool simple) const
2096 : {
2097 20 : if (simple)
2098 : {
2099 : //pp_string (pp, "(");
2100 20 : get_parent_region ()->dump_to_pp (pp, simple);
2101 20 : pp_string (pp, "+");
2102 20 : m_byte_offset->dump_to_pp (pp, simple);
2103 : //pp_string (pp, ")");
2104 : }
2105 : else
2106 : {
2107 0 : pp_string (pp, "offset_region(");
2108 0 : get_parent_region ()->dump_to_pp (pp, simple);
2109 0 : pp_string (pp, ", ");
2110 0 : print_quoted_type (pp, get_type ());
2111 0 : pp_string (pp, ", ");
2112 0 : m_byte_offset->dump_to_pp (pp, simple);
2113 0 : pp_printf (pp, ")");
2114 : }
2115 20 : }
2116 :
2117 : void
2118 0 : offset_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2119 : {
2120 0 : pp_printf (pp, "offset_region");
2121 0 : }
2122 :
2123 : void
2124 0 : offset_region::
2125 : add_dump_widget_children_for_region (text_art::tree_widget &w,
2126 : symbolic::node_dump_state &nds) const
2127 : {
2128 0 : w.add_child (m_byte_offset->make_dump_widget (nds, "m_byte_offset"));
2129 0 : }
2130 :
2131 : void
2132 219 : offset_region::accept_node_visitor (symbolic::node_visitor &v) const
2133 : {
2134 219 : if (v.visit_region (*this))
2135 : {
2136 219 : get_parent_region ()->accept_node_visitor (v);
2137 219 : m_byte_offset->accept_node_visitor (v);
2138 : }
2139 219 : }
2140 :
2141 : std::unique_ptr<json::object>
2142 0 : offset_region::to_json () const
2143 : {
2144 0 : auto obj = region::make_json_obj ("offset_region");
2145 0 : obj->set ("byte_offset", m_byte_offset->to_json ());
2146 0 : return obj;
2147 : }
2148 :
2149 : std::unique_ptr<diagnostics::markup::node>
2150 0 : offset_region::make_markup_node (symbolic::markup_context &) const
2151 : {
2152 0 : return diagnostics::markup::make_text_node ("offset_region");
2153 : }
2154 :
2155 : const svalue *
2156 0 : offset_region::get_bit_offset (region_model_manager *mgr) const
2157 : {
2158 0 : const svalue *bits_per_byte_sval
2159 0 : = mgr->get_or_create_int_cst (NULL_TREE, BITS_PER_UNIT);
2160 0 : return mgr->get_or_create_binop (NULL_TREE, MULT_EXPR,
2161 0 : m_byte_offset, bits_per_byte_sval);
2162 : }
2163 :
2164 : const region::symbolic_bit_count *
2165 4131 : offset_region::
2166 : maybe_get_bit_offset_relative_to_parent (region_model_manager &mgr) const
2167 : {
2168 4131 : auto &scalar_mgr = mgr.get_node_manager ().get_scalars ();
2169 4131 : auto &eight_bits = scalar_mgr.get_bits ().get_concrete (8_bits);
2170 4131 : auto &unitless_byte_offset
2171 4131 : = scalar_mgr.get_unitless ().get_scalar_from_svalue (*m_byte_offset);
2172 4131 : return &(eight_bits * unitless_byte_offset);
2173 : }
2174 :
2175 : const region::symbolic_byte_count *
2176 560 : offset_region::
2177 : maybe_get_byte_offset_relative_to_parent (region_model_manager &mgr) const
2178 : {
2179 560 : auto &scalar_mgr = mgr.get_node_manager ().get_scalars ();
2180 560 : return &scalar_mgr.get_bytes ().get_scalar_from_svalue (*m_byte_offset);
2181 : }
2182 :
2183 : /* class sized_region : public region. */
2184 :
2185 : /* Implementation of region::accept vfunc for sized_region. */
2186 :
2187 : void
2188 0 : sized_region::accept (visitor *v) const
2189 : {
2190 0 : region::accept (v);
2191 0 : m_byte_size_sval->accept (v);
2192 0 : }
2193 :
2194 : /* Implementation of region::dump_to_pp vfunc for sized_region. */
2195 :
2196 : void
2197 18 : sized_region::dump_to_pp (pretty_printer *pp, bool simple) const
2198 : {
2199 18 : if (simple)
2200 : {
2201 11 : pp_string (pp, "SIZED_REG(");
2202 11 : get_parent_region ()->dump_to_pp (pp, simple);
2203 11 : pp_string (pp, ", ");
2204 11 : m_byte_size_sval->dump_to_pp (pp, simple);
2205 11 : pp_string (pp, ")");
2206 : }
2207 : else
2208 : {
2209 7 : pp_string (pp, "sized_region(");
2210 7 : get_parent_region ()->dump_to_pp (pp, simple);
2211 7 : pp_string (pp, ", ");
2212 7 : m_byte_size_sval->dump_to_pp (pp, simple);
2213 7 : pp_printf (pp, ")");
2214 : }
2215 18 : }
2216 :
2217 : void
2218 0 : sized_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2219 : {
2220 0 : pp_printf (pp, "sized_region");
2221 0 : }
2222 :
2223 : void
2224 0 : sized_region::
2225 : add_dump_widget_children_for_region (text_art::tree_widget &w,
2226 : symbolic::node_dump_state &nds) const
2227 : {
2228 0 : w.add_child (m_byte_size_sval->make_dump_widget (nds, "m_byte_size_sval"));
2229 0 : }
2230 :
2231 : void
2232 37034 : sized_region::accept_node_visitor (symbolic::node_visitor &v) const
2233 : {
2234 37034 : if (v.visit_region (*this))
2235 : {
2236 37034 : get_parent_region ()->accept_node_visitor (v);
2237 37034 : m_byte_size_sval->accept_node_visitor (v);
2238 : }
2239 37034 : }
2240 :
2241 : std::unique_ptr<json::object>
2242 0 : sized_region::to_json () const
2243 : {
2244 0 : auto obj = region::make_json_obj ("sized_region");
2245 0 : obj->set ("byte_size_sval", m_byte_size_sval->to_json ());
2246 0 : return obj;
2247 : }
2248 :
2249 : std::unique_ptr<diagnostics::markup::node>
2250 0 : sized_region::make_markup_node (symbolic::markup_context &) const
2251 : {
2252 0 : return diagnostics::markup::make_text_node ("sized_region");
2253 : }
2254 :
2255 : /* Implementation of region::get_byte_size vfunc for sized_region. */
2256 :
2257 : const symbolic_byte_size *
2258 19233 : sized_region::
2259 : maybe_get_byte_size (symbolic::scalar_manager<concrete_byte_size> &byte_mgr) const
2260 : {
2261 19233 : return &byte_mgr.get_scalar_from_svalue (*m_byte_size_sval);
2262 : }
2263 :
2264 : /* Implementation of region::get_bit_size vfunc for sized_region. */
2265 :
2266 : const symbolic_bit_size *
2267 9637 : sized_region::
2268 : maybe_get_bit_size (symbolic::scalar_manager<concrete_bit_size> &bit_mgr) const
2269 : {
2270 9637 : auto &byte_mgr = bit_mgr.get_node_manager ().get_scalars ().get_bytes ();
2271 9637 : auto &sym_byte_size = byte_mgr.get_scalar_from_svalue (*m_byte_size_sval);
2272 9637 : return &bits_from_bytes (sym_byte_size);
2273 : }
2274 :
2275 : /* class cast_region : public region. */
2276 :
2277 : /* Implementation of region::dump_to_pp vfunc for cast_region. */
2278 :
2279 : void
2280 15 : cast_region::dump_to_pp (pretty_printer *pp, bool simple) const
2281 : {
2282 15 : if (simple)
2283 : {
2284 8 : pp_string (pp, "CAST_REG(");
2285 8 : print_quoted_type (pp, get_type ());
2286 8 : pp_string (pp, ", ");
2287 8 : get_parent_region ()->dump_to_pp (pp, simple);
2288 8 : pp_string (pp, ")");
2289 : }
2290 : else
2291 : {
2292 7 : pp_string (pp, "cast_region(");
2293 7 : get_parent_region ()->dump_to_pp (pp, simple);
2294 7 : pp_string (pp, ", ");
2295 7 : print_quoted_type (pp, get_type ());
2296 7 : pp_printf (pp, ")");
2297 : }
2298 15 : }
2299 :
2300 : void
2301 0 : cast_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2302 : {
2303 0 : pp_printf (pp, "cast_region");
2304 0 : }
2305 :
2306 : void
2307 0 : cast_region::accept_node_visitor (symbolic::node_visitor &v) const
2308 : {
2309 0 : if (v.visit_region (*this))
2310 0 : get_parent_region ()->accept_node_visitor (v);
2311 0 : }
2312 :
2313 : std::unique_ptr<json::object>
2314 0 : cast_region::to_json () const
2315 : {
2316 0 : return region::make_json_obj ("cast_region");
2317 : }
2318 :
2319 : std::unique_ptr<diagnostics::markup::node>
2320 0 : cast_region::make_markup_node (symbolic::markup_context &) const
2321 : {
2322 0 : return diagnostics::markup::make_text_node ("cast_region");
2323 : }
2324 :
2325 : const region::symbolic_bit_count *
2326 0 : cast_region::
2327 : maybe_get_bit_offset_relative_to_parent (region_model_manager &) const
2328 : {
2329 0 : return nullptr;
2330 : }
2331 :
2332 : const region::symbolic_byte_count *
2333 0 : cast_region::
2334 : maybe_get_byte_offset_relative_to_parent (region_model_manager &) const
2335 : {
2336 0 : return nullptr;
2337 : }
2338 :
2339 : /* class heap_allocated_region : public region. */
2340 :
2341 : /* Implementation of region::dump_to_pp vfunc for heap_allocated_region. */
2342 :
2343 : void
2344 120 : heap_allocated_region::dump_to_pp (pretty_printer *pp, bool simple) const
2345 : {
2346 120 : if (simple)
2347 120 : pp_printf (pp, "HEAP_ALLOCATED_REGION(%i)", get_id ());
2348 : else
2349 0 : pp_printf (pp, "heap_allocated_region(%i)", get_id ());
2350 120 : }
2351 :
2352 : void
2353 0 : heap_allocated_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2354 : {
2355 0 : pp_printf (pp, "heap_allocated_region");
2356 0 : }
2357 :
2358 : void
2359 2512415 : heap_allocated_region::accept_node_visitor (symbolic::node_visitor &v) const
2360 : {
2361 2512415 : v.visit_region (*this);
2362 2512415 : }
2363 :
2364 : std::unique_ptr<json::object>
2365 105 : heap_allocated_region::to_json () const
2366 : {
2367 105 : return region::make_json_obj ("heap_allocated_region");
2368 : }
2369 :
2370 : std::unique_ptr<diagnostics::markup::node>
2371 0 : heap_allocated_region::make_markup_node (symbolic::markup_context &) const
2372 : {
2373 0 : return diagnostics::markup::make_text_node ("heap_allocated_region");
2374 : }
2375 :
2376 : /* class alloca_region : public region. */
2377 :
2378 : /* Implementation of region::dump_to_pp vfunc for alloca_region. */
2379 :
2380 : void
2381 0 : alloca_region::dump_to_pp (pretty_printer *pp, bool simple) const
2382 : {
2383 0 : if (simple)
2384 0 : pp_printf (pp, "ALLOCA_REGION(%i)", get_id ());
2385 : else
2386 0 : pp_printf (pp, "alloca_region(%i)", get_id ());
2387 0 : }
2388 :
2389 : void
2390 0 : alloca_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2391 : {
2392 0 : pp_printf (pp, "alloca_region");
2393 0 : }
2394 :
2395 : void
2396 117614 : alloca_region::accept_node_visitor (symbolic::node_visitor &v) const
2397 : {
2398 117614 : v.visit_region (*this);
2399 117614 : }
2400 :
2401 : std::unique_ptr<json::object>
2402 0 : alloca_region::to_json () const
2403 : {
2404 0 : return region::make_json_obj ("alloca_region");
2405 : }
2406 :
2407 : std::unique_ptr<diagnostics::markup::node>
2408 0 : alloca_region::make_markup_node (symbolic::markup_context &) const
2409 : {
2410 0 : return diagnostics::markup::make_text_node ("alloca_region");
2411 : }
2412 :
2413 : /* class string_region : public region. */
2414 :
2415 : /* Implementation of region::dump_to_pp vfunc for string_region. */
2416 :
2417 : void
2418 0 : string_region::dump_to_pp (pretty_printer *pp, bool simple) const
2419 : {
2420 0 : if (simple)
2421 0 : dump_tree (pp, m_string_cst);
2422 : else
2423 : {
2424 0 : pp_string (pp, "string_region(");
2425 0 : dump_tree (pp, m_string_cst);
2426 0 : if (!flag_dump_noaddr)
2427 : {
2428 0 : pp_string (pp, " (");
2429 0 : pp_pointer (pp, m_string_cst);
2430 0 : pp_string (pp, "))");
2431 : }
2432 : }
2433 0 : }
2434 :
2435 : void
2436 0 : string_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2437 : {
2438 0 : pp_string (pp, "string_region(");
2439 0 : dump_tree (pp, m_string_cst);
2440 0 : pp_string (pp, ")");
2441 0 : }
2442 :
2443 : void
2444 236660 : string_region::accept_node_visitor (symbolic::node_visitor &v) const
2445 : {
2446 236660 : if (v.visit_region (*this))
2447 236660 : get_parent_region ()->accept_node_visitor (v);
2448 236660 : }
2449 :
2450 : std::unique_ptr<json::object>
2451 0 : string_region::to_json () const
2452 : {
2453 0 : auto obj = region::make_json_obj ("string_region");
2454 0 : obj->set ("string", tree_to_json (m_string_cst));
2455 0 : return obj;
2456 : }
2457 :
2458 : std::unique_ptr<diagnostics::markup::node>
2459 0 : string_region::make_markup_node (symbolic::markup_context &) const
2460 : {
2461 0 : return diagnostics::markup::make_text_node ("string_region");
2462 : }
2463 :
2464 : /* class bit_range_region : public region. */
2465 :
2466 : /* Implementation of region::dump_to_pp vfunc for bit_range_region. */
2467 :
2468 : void
2469 0 : bit_range_region::dump_to_pp (pretty_printer *pp, bool simple) const
2470 : {
2471 0 : if (simple)
2472 : {
2473 0 : pp_string (pp, "BIT_RANGE_REG(");
2474 0 : get_parent_region ()->dump_to_pp (pp, simple);
2475 0 : pp_string (pp, ", ");
2476 0 : m_bits.dump_to_pp (pp);
2477 0 : pp_string (pp, ")");
2478 : }
2479 : else
2480 : {
2481 0 : pp_string (pp, "bit_range_region(");
2482 0 : get_parent_region ()->dump_to_pp (pp, simple);
2483 0 : pp_string (pp, ", ");
2484 0 : m_bits.dump_to_pp (pp);
2485 0 : pp_printf (pp, ")");
2486 : }
2487 0 : }
2488 :
2489 : void
2490 0 : bit_range_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2491 : {
2492 0 : pp_printf (pp, "bit_range_region(m_bits: ");
2493 0 : m_bits.dump_to_pp (pp);
2494 0 : pp_string (pp, ")");
2495 0 : }
2496 :
2497 : void
2498 0 : bit_range_region::accept_node_visitor (symbolic::node_visitor &v) const
2499 : {
2500 0 : if (v.visit_region (*this))
2501 0 : get_parent_region ()->accept_node_visitor (v);
2502 0 : }
2503 :
2504 : std::unique_ptr<json::object>
2505 0 : bit_range_region::to_json () const
2506 : {
2507 0 : auto obj = region::make_json_obj ("bit_range_region");
2508 0 : obj->set ("bits", m_bits.to_json ());
2509 0 : return obj;
2510 : }
2511 :
2512 : std::unique_ptr<diagnostics::markup::node>
2513 4 : bit_range_region::make_markup_node (symbolic::markup_context &markup_ctxt) const
2514 : {
2515 4 : auto result = std::make_unique<diagnostics::markup::compound_node> ();
2516 4 : result->add_child ("bit_range_region (");
2517 4 : result->add_child (get_parent_region ()->make_markup_node (markup_ctxt));
2518 4 : result->add_child (", bits=");
2519 4 : result->add_child (m_bits.make_markup_node ());
2520 4 : result->add_child (")");
2521 4 : return result;
2522 4 : }
2523 :
2524 : const symbolic_byte_size *
2525 0 : bit_range_region::
2526 : maybe_get_byte_size (symbolic::scalar_manager<concrete_byte_size> &byte_mgr) const
2527 : {
2528 0 : gcc_unreachable ();
2529 : }
2530 :
2531 : /* Implementation of region::get_bit_size vfunc for bit_range_region. */
2532 :
2533 : const symbolic_bit_size *
2534 524 : bit_range_region::
2535 : maybe_get_bit_size (symbolic::scalar_manager<concrete_bit_size> &bit_mgr) const
2536 : {
2537 524 : return &symbolic_from_concrete (m_bits.get_size (), bit_mgr);
2538 : }
2539 :
2540 : const region::symbolic_bit_count *
2541 439 : bit_range_region::
2542 : maybe_get_bit_offset_relative_to_parent (region_model_manager &mgr) const
2543 : {
2544 439 : auto &node_mgr = mgr.get_node_manager ();
2545 439 : auto &bit_mgr = node_mgr.get_scalars ().get_bits ();
2546 439 : return &bit_mgr.get_concrete (m_bits.get_start_offset ());
2547 : }
2548 :
2549 : const region::symbolic_byte_count *
2550 0 : bit_range_region::
2551 : maybe_get_byte_offset_relative_to_parent (region_model_manager &mgr) const
2552 : {
2553 0 : gcc_unreachable ();
2554 : }
2555 :
2556 : /* class var_arg_region : public region. */
2557 :
2558 : void
2559 0 : var_arg_region::dump_to_pp (pretty_printer *pp, bool simple) const
2560 : {
2561 0 : if (simple)
2562 : {
2563 0 : pp_string (pp, "VAR_ARG_REG(");
2564 0 : get_parent_region ()->dump_to_pp (pp, simple);
2565 0 : pp_printf (pp, ", arg_idx: %d)", m_idx);
2566 : }
2567 : else
2568 : {
2569 0 : pp_string (pp, "var_arg_region(");
2570 0 : get_parent_region ()->dump_to_pp (pp, simple);
2571 0 : pp_printf (pp, ", arg_idx: %d)", m_idx);
2572 : }
2573 0 : }
2574 :
2575 : void
2576 0 : var_arg_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2577 : {
2578 0 : pp_printf (pp, "var_arg_region(arg_idx: %i)", m_idx);
2579 0 : }
2580 :
2581 : void
2582 47787 : var_arg_region::accept_node_visitor (symbolic::node_visitor &v) const
2583 : {
2584 47787 : if (v.visit_region (*this))
2585 47787 : get_parent_region ()->accept_node_visitor (v);
2586 47787 : }
2587 :
2588 : std::unique_ptr<json::object>
2589 0 : var_arg_region::to_json () const
2590 : {
2591 0 : auto obj = region::make_json_obj ("var_arg_region");
2592 0 : obj->set_integer ("index", m_idx);
2593 0 : return obj;
2594 : }
2595 :
2596 : std::unique_ptr<diagnostics::markup::node>
2597 0 : var_arg_region::make_markup_node (symbolic::markup_context &) const
2598 : {
2599 0 : return diagnostics::markup::make_text_node ("var_arg_region");
2600 : }
2601 :
2602 : /* Get the frame_region for this var_arg_region. */
2603 :
2604 : const frame_region *
2605 625 : var_arg_region::get_frame_region () const
2606 : {
2607 625 : gcc_assert (get_parent_region ());
2608 625 : return as_a <const frame_region *> (get_parent_region ());
2609 : }
2610 :
2611 : /* class errno_region : public region. */
2612 :
2613 : void
2614 0 : errno_region::dump_to_pp (pretty_printer *pp, bool simple) const
2615 : {
2616 0 : if (simple)
2617 0 : pp_string (pp, "errno_region");
2618 : else
2619 0 : pp_string (pp, "errno_region()");
2620 0 : }
2621 :
2622 : void
2623 0 : errno_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2624 : {
2625 0 : pp_printf (pp, "errno_region");
2626 0 : }
2627 :
2628 : void
2629 115776 : errno_region::accept_node_visitor (symbolic::node_visitor &v) const
2630 : {
2631 115776 : if (v.visit_region (*this))
2632 115776 : get_parent_region ()->accept_node_visitor (v);
2633 115776 : }
2634 :
2635 : std::unique_ptr<json::object>
2636 0 : errno_region::to_json () const
2637 : {
2638 0 : return region::make_json_obj ("errno");
2639 : }
2640 :
2641 : std::unique_ptr<diagnostics::markup::node>
2642 0 : errno_region::make_markup_node (symbolic::markup_context &) const
2643 : {
2644 0 : return diagnostics::markup::make_text_node ("errno");
2645 : }
2646 :
2647 : /* class private_region : public region. */
2648 :
2649 : void
2650 0 : private_region::dump_to_pp (pretty_printer *pp, bool simple) const
2651 : {
2652 0 : if (simple)
2653 0 : pp_printf (pp, "PRIVATE_REG(%qs)", m_desc);
2654 : else
2655 0 : pp_printf (pp, "private_region(%qs)", m_desc);
2656 0 : }
2657 :
2658 : void
2659 0 : private_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2660 : {
2661 0 : pp_printf (pp, "private_region(%qs)", m_desc);
2662 0 : }
2663 :
2664 : void
2665 3471 : private_region::accept_node_visitor (symbolic::node_visitor &v) const
2666 : {
2667 3471 : if (v.visit_region (*this))
2668 3471 : get_parent_region ()->accept_node_visitor (v);
2669 3471 : }
2670 :
2671 : std::unique_ptr<json::object>
2672 0 : private_region::to_json () const
2673 : {
2674 0 : auto obj = region::make_json_obj ("private_region");
2675 0 : obj->set_string ("desc", m_desc);
2676 0 : return obj;
2677 : }
2678 :
2679 : std::unique_ptr<diagnostics::markup::node>
2680 0 : private_region::make_markup_node (symbolic::markup_context &) const
2681 : {
2682 0 : return diagnostics::markup::make_text_node ("private_region");
2683 : }
2684 :
2685 : /* class unknown_region : public region. */
2686 :
2687 : /* Implementation of region::dump_to_pp vfunc for unknown_region. */
2688 :
2689 : void
2690 36 : unknown_region::dump_to_pp (pretty_printer *pp, bool /*simple*/) const
2691 : {
2692 36 : pp_string (pp, "UNKNOWN_REGION");
2693 36 : }
2694 :
2695 : void
2696 0 : unknown_region::print_region_for_dump_widget_label (pretty_printer *pp) const
2697 : {
2698 0 : pp_printf (pp, "unknown_region");
2699 0 : }
2700 :
2701 : void
2702 1772 : unknown_region::accept_node_visitor (symbolic::node_visitor &v) const
2703 : {
2704 1772 : if (v.visit_region (*this))
2705 1772 : get_parent_region ()->accept_node_visitor (v);
2706 1772 : }
2707 :
2708 : std::unique_ptr<json::object>
2709 0 : unknown_region::to_json () const
2710 : {
2711 0 : return region::make_json_obj ("unknown_region");
2712 : }
2713 :
2714 : std::unique_ptr<diagnostics::markup::node>
2715 0 : unknown_region::make_markup_node (symbolic::markup_context &) const
2716 : {
2717 0 : return diagnostics::markup::make_text_node ("unknown_region");
2718 : }
2719 :
2720 : } // namespace ana
2721 :
2722 : #endif /* #if ENABLE_ANALYZER */
|