Line data Source code
1 : /* Text art visualizations within -fanalyzer.
2 : Copyright (C) 2023-2026 Free Software Foundation, Inc.
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 : #define INCLUDE_ALGORITHM
21 : #define INCLUDE_MAP
22 : #define INCLUDE_SET
23 : #include "analyzer/common.h"
24 :
25 : #include "fold-const.h"
26 : #include "intl.h"
27 :
28 : #include "diagnostics/markup.h"
29 :
30 : #include "text-art/ruler.h"
31 :
32 : #include "analyzer/region-model.h"
33 : #include "analyzer/access-diagram.h"
34 : #include "analyzer/analyzer-selftests.h"
35 :
36 : #if ENABLE_ANALYZER
37 :
38 : /* Consider this code:
39 : int32_t arr[10];
40 : arr[10] = x;
41 : where we've emitted a buffer overflow diagnostic like this:
42 : out-of-bounds write from byte 40 till byte 43 but 'arr' ends at byte 40
43 :
44 : We want to emit a diagram that visualizes:
45 : - the spatial relationship between the valid region to access, versus
46 : the region that was actually accessed: does it overlap, was it touching,
47 : close, or far away? Was it before or after in memory? What are the
48 : relative sizes involved?
49 : - the direction of the access (read vs write)
50 :
51 : The following code supports emitting diagrams similar to the following:
52 :
53 : # +--------------------------------+
54 : # |write from ‘x’ (type: ‘int32_t’)|
55 : # +--------------------------------+
56 : # |
57 : # |
58 : # v
59 : # +---------+-----------+-----------+ +--------------------------------+
60 : # | [0] | ... | [9] | | after valid range |
61 : # +---------+-----------+-----------+ | |
62 : # | ‘arr’ (type: ‘int32_t[10]’) | | |
63 : # +---------------------------------+ +--------------------------------+
64 : # |~~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~| |~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~|
65 : # | |
66 : # +---------+--------+ +---------+---------+
67 : # |capacity: 40 bytes| |overflow of 4 bytes|
68 : # +------------------+ +-------------------+
69 :
70 : where the diagram is laid out via table columns where each table column
71 : represents either a range of bits/bytes, or is a spacing column (to highlight
72 : the boundary between valid vs invalid accesses). The table columns can be
73 : seen via -fanalyzer-debug-text-art. For example, here there are 5 table
74 : columns ("tc0" through "tc4"):
75 :
76 : # +---------+-----------+-----------+---+--------------------------------+
77 : # | tc0 | tc1 | tc2 |tc3| tc4 |
78 : # +---------+-----------+-----------+---+--------------------------------+
79 : # |bytes 0-3|bytes 4-35 |bytes 36-39| | bytes 40-43 |
80 : # +---------+-----------+-----------+ +--------------------------------+
81 : #
82 : # +--------------------------------+
83 : # |write from ‘x’ (type: ‘int32_t’)|
84 : # +--------------------------------+
85 : # |
86 : # |
87 : # v
88 : # +---------+-----------+-----------+ +--------------------------------+
89 : # | [0] | ... | [9] | | after valid range |
90 : # +---------+-----------+-----------+ | |
91 : # | ‘arr’ (type: ‘int32_t[10]’) | | |
92 : # +---------------------------------+ +--------------------------------+
93 : # |~~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~| |~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~|
94 : # | |
95 : # +---------+--------+ +---------+---------+
96 : # |capacity: 40 bytes| |overflow of 4 bytes|
97 : # +------------------+ +-------------------+
98 :
99 : The diagram is built up from the following:
100 :
101 : # +--------------------------------+
102 : # | ITEM FOR SVALUE/ACCESSED REGION|
103 : # +--------------------------------+
104 : # |
105 : # | DIRECTION WIDGET
106 : # v
107 : # +---------------------------------+ +--------------------------------+
108 : # | VALID REGION | | INVALID ACCESS |
109 : # +---------------------------------+ +--------------------------------+
110 : #
111 : # | VALID-VS-INVALID RULER |
112 :
113 : i.e. a vbox_widget containing 4 child widgets laid out vertically:
114 : - ALIGNED CHILD WIDGET: ITEM FOR SVALUE/ACCESSED REGION
115 : - DIRECTION WIDGET
116 : - ALIGNED CHILD WIDGET: VALID AND INVALID ACCESSES
117 : - VALID-VS-INVALID RULER.
118 :
119 : A more complicated example, given this overflow:
120 : char buf[100];
121 : strcpy (buf, LOREM_IPSUM);
122 :
123 : 01| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
124 : 02| |[0]|[1]|[2]|[3]|[4]|[5]| ... |[440]|[441]|[442]|[443]|[444]|[445]|
125 : 03| +---+---+---+---+---+---+ +-----+-----+-----+-----+-----+-----+
126 : 04| |'L'|'o'|'r'|'e'|'m'|' '| | 'o' | 'r' | 'u' | 'm' | '.' | NUL |
127 : 05| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
128 : 06| | string literal (type: 'char[446]') |
129 : 07| +----------------------------------------------------------------------+
130 : 08| | | | | | | | | | | | | | | |
131 : 09| | | | | | | | | | | | | | | |
132 : 10| v v v v v v v v v v v v v v v
133 : 11| +---+---------------------+----++--------------------------------------+
134 : 12| |[0]| ... |[99]|| after valid range |
135 : 13| +---+---------------------+----+| |
136 : 14| | 'buf' (type: 'char[100]') || |
137 : 15| +------------------------------++--------------------------------------+
138 : 16| |~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~||~~~~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~~~~|
139 : 17| | |
140 : 18| +---------+---------+ +----------+----------+
141 : 19| |capacity: 100 bytes| |overflow of 346 bytes|
142 : 20| +-------------------+ +---------------------+
143 :
144 : which is:
145 :
146 : 01| ALIGNED CHILD WIDGET (lines 01-07): (string_region_spatial_item)-+-----+
147 : 02| |[0]|[1]|[2]|[3]|[4]|[5]| ... |[440]|[441]|[442]|[443]|[444]|[445]|
148 : 03| +---+---+---+---+---+---+ +-----+-----+-----+-----+-----+-----+
149 : 04| |'L'|'o'|'r'|'e'|'m'|' '| | 'o' | 'r' | 'u' | 'm' | '.' | NUL |
150 : 05| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
151 : 06| | string literal (type: 'char[446]') |
152 : 07| +----------------------------------------------------------------------+
153 : 08| DIRECTION WIDGET (lines 08-10) | | | | | | |
154 : 09| | | | | | | | | | | | | | | |
155 : 10| v v v v v v v v v v v v v v v
156 : 11| ALIGNED CHILD WIDGET (lines 11-15)-------------------------------------+
157 : 12| VALID REGION ... |[99]|| INVALID ACCESS |
158 : 13| +---+---------------------+----+| |
159 : 14| | 'buf' (type: 'char[100]') || |
160 : 15| +------------------------------++--------------------------------------+
161 : 16| VALID-VS-INVALID RULER (lines 16-20): ~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~~~~|
162 : 17| | |
163 : 18| +---------+---------+ +----------+----------+
164 : 19| |capacity: 100 bytes| |overflow of 346 bytes|
165 : 20| +-------------------+ +---------------------+
166 :
167 : We build the diagram in several phases:
168 : - (1) we construct an access_diagram_impl widget. Within the ctor, we have
169 : these subphases:
170 : - (1.1) find all of the boundaries of interest
171 : - (1.2) use the boundaries to build a bit_table_map, associating bit ranges
172 : with table columns (e.g. "byte 0 is column 0, bytes 1-98 are column 2" etc)
173 : - (1.3) create child widgets that share this table-based geometry
174 : - (2) ask the widget for its size request
175 : - (2.1) column widths and row heights for the table are computed by
176 : access_diagram_impl::calc_req_size
177 : - (2.2) child widgets request sizes based on these widths/heights
178 : - (3) create a canvas of the appropriate size
179 : - (4) paint the widget hierarchy to the canvas. */
180 :
181 :
182 : using namespace text_art;
183 :
184 : namespace ana {
185 :
186 : static styled_string
187 : fmt_styled_string (style_manager &sm,
188 : const char *fmt, ...)
189 : ATTRIBUTE_GCC_DIAG(2, 3);
190 :
191 : static styled_string
192 749 : fmt_styled_string (style_manager &sm,
193 : const char *fmt, ...)
194 : {
195 749 : va_list ap;
196 749 : va_start (ap, fmt);
197 749 : styled_string result
198 749 : = styled_string::from_fmt_va (sm, default_tree_printer, fmt, &ap);
199 749 : va_end (ap);
200 749 : return result;
201 : }
202 :
203 : class access_diagram_impl;
204 : class bit_to_table_map;
205 :
206 : static styled_string
207 28 : get_access_size_str (style_manager &sm,
208 : const access_operation &op,
209 : symbolic_bit_range accessed_range,
210 : tree type)
211 : {
212 28 : bit_size_expr num_bits (accessed_range.get_size ());
213 28 : if (op.m_dir == access_direction::read)
214 : {
215 13 : if (auto p
216 : = num_bits.maybe_get_formatted_str (sm, op.m_model,
217 13 : _("read of %e bit"),
218 13 : _("read of %e bits"),
219 13 : _("read of %e byte"),
220 13 : _("read of %e bytes"),
221 13 : _("read of %qs bits"),
222 13 : _("read of %qs bytes")))
223 13 : return std::move (*p.get ());
224 : }
225 : else
226 : {
227 15 : if (auto p
228 : = num_bits.maybe_get_formatted_str (sm, op.m_model,
229 15 : _("write of %e bit"),
230 15 : _("write of %e bits"),
231 15 : _("write of %e byte"),
232 15 : _("write of %e bytes"),
233 15 : _("write of %qs bits"),
234 15 : _("write of %qs bytes")))
235 15 : return std::move (*p.get ());
236 : }
237 :
238 0 : if (type)
239 : {
240 0 : if (op.m_dir == access_direction::read)
241 0 : return fmt_styled_string (sm, _("read of %qT"), type);
242 : else
243 0 : return fmt_styled_string (sm, _("write of %qT"), type);
244 : }
245 0 : if (op.m_dir == access_direction::read)
246 0 : return styled_string (sm, _("read"));
247 : else
248 0 : return styled_string (sm, _("write"));
249 : }
250 :
251 : /* Subroutine of clean_up_for_diagram. */
252 :
253 : static tree
254 0 : strip_any_cast (tree expr)
255 : {
256 0 : if (TREE_CODE (expr) == NOP_EXPR
257 0 : || TREE_CODE (expr) == NON_LVALUE_EXPR)
258 0 : expr = TREE_OPERAND (expr, 0);
259 0 : return expr;
260 : }
261 :
262 : /* Duplicate EXPR, replacing any SSA names with the underlying variable. */
263 :
264 : tree
265 0 : remove_ssa_names (tree expr)
266 : {
267 0 : if (TREE_CODE (expr) == SSA_NAME
268 0 : && SSA_NAME_VAR (expr))
269 : return SSA_NAME_VAR (expr);
270 0 : tree t = copy_node (expr);
271 0 : for (int i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
272 0 : if (TREE_OPERAND (expr, i))
273 0 : TREE_OPERAND (t, i) = remove_ssa_names (TREE_OPERAND (expr, i));
274 : return t;
275 : }
276 :
277 : /* We want to be able to print tree expressions from the analyzer,
278 : which is in the middle end.
279 :
280 : We could use the front-end pretty_printer's formatting routine,
281 : but:
282 : (a) some have additional state in a pretty_printer subclass, so we'd
283 : need to clone global_dc->printer
284 : (b) the "aka" type information added by the C and C++ frontends are
285 : too verbose when building a diagram, and there isn't a good way to ask
286 : for a less verbose version of them.
287 :
288 : Hence we use default_tree_printer.
289 : However, we want to avoid printing SSA names, and instead print the
290 : underlying var name.
291 : Ideally there would be a better tree printer for use by middle end
292 : warnings, but as workaround, this function clones a tree, replacing
293 : SSA names with the var names. */
294 :
295 : tree
296 0 : clean_up_for_diagram (tree expr)
297 : {
298 0 : tree without_ssa_names = remove_ssa_names (expr);
299 0 : return strip_any_cast (without_ssa_names);
300 : }
301 :
302 : /* struct bit_size_expr. */
303 :
304 : /* Attempt to generate a user-facing styled string that mentions this
305 : bit_size_expr.
306 : Use MODEL for extracting representative tree values where necessary.
307 : The CONCRETE_* format strings should contain a single %e.
308 : The SYMBOLIC_* format strings should contain a single %qs.
309 : Return nullptr if unable to represent the expression. */
310 :
311 : std::unique_ptr<text_art::styled_string>
312 178 : bit_size_expr::maybe_get_formatted_str (text_art::style_manager &sm,
313 : const region_model &model,
314 : const char *concrete_single_bit_fmt,
315 : const char *concrete_plural_bits_fmt,
316 : const char *concrete_single_byte_fmt,
317 : const char *concrete_plural_bytes_fmt,
318 : const char *symbolic_bits_fmt,
319 : const char *symbolic_bytes_fmt) const
320 : {
321 178 : const diagnostics::markup::lowering_options markup_lowering_opts;
322 178 : if (auto *sym_byte_size = maybe_bytes_from_bits (m_num_bits))
323 : {
324 177 : concrete_byte_size conc_num_bytes;
325 177 : if (concrete_from_symbolic (*sym_byte_size, &conc_num_bytes))
326 : {
327 145 : pp_element_integer e_num_bytes (conc_num_bytes.get_integer ());
328 145 : if (conc_num_bytes == 1_byte)
329 23 : return std::make_unique <text_art::styled_string>
330 46 : (fmt_styled_string (sm, concrete_single_byte_fmt,
331 23 : &e_num_bytes));
332 : else
333 122 : return std::make_unique <text_art::styled_string>
334 244 : (fmt_styled_string (sm, concrete_plural_bytes_fmt,
335 122 : &e_num_bytes));
336 145 : }
337 : else
338 : {
339 32 : symbolic::markup_context ctxt (&model, true);
340 32 : auto markup = sym_byte_size->make_markup_node (ctxt);
341 32 : auto lowered = markup->lower (markup_lowering_opts);
342 32 : pretty_printer pp;
343 32 : pp_format_decoder (&pp) = default_tree_printer;
344 32 : lowered->print_to_pp (&pp);
345 32 : return std::make_unique <text_art::styled_string>
346 32 : (fmt_styled_string (sm, symbolic_bytes_fmt,
347 32 : pp_formatted_text (&pp)));
348 32 : }
349 177 : }
350 : else
351 : {
352 1 : concrete_bit_size conc_num_bits;
353 1 : if (concrete_from_symbolic (m_num_bits, &conc_num_bits))
354 : {
355 0 : pp_element_integer e_num_bits (conc_num_bits.get_integer ());
356 0 : if (conc_num_bits == 1_bit)
357 0 : return std::make_unique <text_art::styled_string>
358 0 : (fmt_styled_string (sm, concrete_single_bit_fmt,
359 0 : &e_num_bits));
360 : else
361 0 : return std::make_unique <text_art::styled_string>
362 0 : (fmt_styled_string (sm, concrete_plural_bits_fmt,
363 0 : &e_num_bits));
364 0 : }
365 : else
366 : {
367 1 : symbolic::markup_context ctxt (&model, true);
368 1 : auto markup = m_num_bits.make_markup_node (ctxt);
369 1 : auto lowered = markup->lower (markup_lowering_opts);
370 1 : pretty_printer pp;
371 1 : pp_format_decoder (&pp) = default_tree_printer;
372 1 : lowered->print_to_pp (&pp);
373 1 : return std::make_unique <text_art::styled_string>
374 1 : (fmt_styled_string (sm, symbolic_bits_fmt,
375 1 : pp_formatted_text (&pp)));
376 1 : }
377 1 : }
378 : }
379 :
380 : /* A sloppy folding to use when building access diagrams,
381 : in the hope that the results will be easier to simplify/draw. */
382 :
383 : template<typename ConcreteValueType>
384 : const symbolic::scalar<ConcreteValueType> &
385 : fold_scalar_for_access_diagram (const symbolic::scalar<ConcreteValueType> &s);
386 :
387 : template<typename ConcreteValueType>
388 : const symbolic::scalar<ConcreteValueType> &
389 1741 : fold_svalue_for_access_diagram (const svalue &sval,
390 : symbolic::scalar_manager<ConcreteValueType> &mgr)
391 : {
392 1881 : switch (sval.get_kind ())
393 : {
394 : default:
395 : break;
396 :
397 426 : case SK_CONSTANT:
398 : {
399 426 : tree cst = sval.maybe_get_constant ();
400 426 : gcc_assert (cst);
401 426 : if (TREE_CODE (cst) == INTEGER_CST)
402 : {
403 426 : integer i = convert_from_integer_cst (cst);
404 426 : return mgr.get_concrete (ConcreteValueType (i));
405 426 : }
406 : }
407 : break;
408 :
409 140 : case SK_UNARYOP:
410 : {
411 140 : const unaryop_svalue *unaryop = as_a<const unaryop_svalue *> (&sval);
412 140 : switch (unaryop->get_op ())
413 : {
414 : default:
415 : break;
416 140 : case NOP_EXPR:
417 : // Blithely ignore casts
418 : return fold_svalue_for_access_diagram<ConcreteValueType>
419 140 : (*unaryop->get_arg (), mgr);
420 : }
421 : }
422 : break;
423 :
424 536 : case SK_BINOP:
425 : {
426 536 : const binop_svalue *binop = as_a<const binop_svalue *> (&sval);
427 536 : switch (binop->get_op ())
428 : {
429 : default:
430 : break;
431 246 : case PLUS_EXPR:
432 : return (fold_svalue_for_access_diagram<ConcreteValueType>
433 246 : (*binop->get_arg0 (), mgr)
434 246 : + fold_svalue_for_access_diagram<ConcreteValueType>
435 492 : (*binop->get_arg1 (), mgr));
436 290 : case MULT_EXPR:
437 : {
438 : /* Put any constant on the unit side. */
439 290 : const svalue *with_unit = binop->get_arg0 ();
440 290 : const svalue *unitless = binop->get_arg1 ();
441 290 : if (unitless->maybe_get_constant ())
442 290 : std::swap (with_unit, unitless);
443 : return (fold_svalue_for_access_diagram<ConcreteValueType>
444 : (*with_unit, mgr)
445 290 : * fold_svalue_for_access_diagram<integer>
446 : (*unitless, mgr.get_unitless_manager ()));
447 : }
448 : }
449 : }
450 : break;
451 : }
452 :
453 779 : return mgr.get_scalar_from_svalue (sval);
454 : }
455 :
456 : template<typename ConcreteValueType>
457 : const symbolic::scalar<ConcreteValueType> &
458 5254 : case_fold_scalar_for_access_diagram (const symbolic::scalar<ConcreteValueType> &s)
459 : {
460 5254 : switch (s.get_kind ())
461 : {
462 0 : default:
463 0 : gcc_unreachable ();
464 :
465 : case symbolic::scalar<ConcreteValueType>::kind::concrete:
466 : return s;
467 :
468 68 : case symbolic::scalar<ConcreteValueType>::kind::sum:
469 : {
470 68 : const symbolic::sum<ConcreteValueType> &sum
471 : = (const symbolic::sum<ConcreteValueType> &)s;
472 68 : std::vector<const symbolic::scalar<ConcreteValueType> *> folded_addends;
473 144 : for (size_t i = 0; i < sum.get_num_symbolic_addends (); ++i)
474 : folded_addends.push_back
475 76 : (&fold_scalar_for_access_diagram<ConcreteValueType>
476 76 : (sum.get_symbolic_addend (i)));
477 68 : if (auto *conc = sum.get_any_concrete_addend ())
478 : folded_addends.push_back
479 60 : (&fold_scalar_for_access_diagram<ConcreteValueType> (*conc));
480 68 : return s.get_mgr ().get_sum (std::move (folded_addends));
481 68 : }
482 : break;
483 :
484 71 : case symbolic::scalar<ConcreteValueType>::kind::product:
485 : {
486 71 : const symbolic::product<ConcreteValueType> &product
487 : = (const symbolic::product<ConcreteValueType> &)s;
488 71 : return s.get_mgr ().get_product
489 71 : (fold_scalar_for_access_diagram (product.get_lhs ()),
490 71 : fold_scalar_for_access_diagram (product.get_rhs ()));
491 : }
492 : break;
493 :
494 669 : case symbolic::scalar<ConcreteValueType>::kind::from_svalue:
495 : {
496 669 : const symbolic::scalar_from_svalue<ConcreteValueType> &subclass
497 : = (const symbolic::scalar_from_svalue<ConcreteValueType> &)s;
498 669 : const svalue &sval = subclass.get_svalue ();
499 669 : return fold_svalue_for_access_diagram<ConcreteValueType> (sval,
500 669 : s.get_mgr ());
501 : }
502 : break;
503 :
504 0 : case symbolic::scalar<ConcreteValueType>::kind::named_test:
505 0 : gcc_unreachable ();
506 : break;
507 :
508 0 : case symbolic::scalar<ConcreteValueType>::kind::bits_from_bytes:
509 : /* Should be handled by caller. */
510 0 : gcc_unreachable ();
511 : break;
512 : }
513 : }
514 :
515 : template<typename ConcreteValueType>
516 : const symbolic::scalar<ConcreteValueType> &
517 926 : fold_scalar_for_access_diagram (const symbolic::scalar<ConcreteValueType> &s)
518 : {
519 278 : return case_fold_scalar_for_access_diagram (s);
520 : }
521 :
522 : template <>
523 : const symbolic_bit_offset &
524 4976 : fold_scalar_for_access_diagram (const symbolic_bit_offset &s)
525 : {
526 4976 : if (auto *from_bytes = s.dyn_cast_bits_from_bytes_scalar ())
527 648 : return s.get_mgr ().get_bits_from_bytes
528 648 : (fold_scalar_for_access_diagram (from_bytes->get_bytes ()));
529 4328 : return case_fold_scalar_for_access_diagram (s);
530 : }
531 :
532 : template<typename ConcreteValueType>
533 : symbolic::range<ConcreteValueType>
534 2488 : fold_range_for_access_diagram (symbolic::range<ConcreteValueType> range)
535 : {
536 2488 : return symbolic::range<ConcreteValueType>
537 2488 : (fold_scalar_for_access_diagram (range.get_start_offset ()),
538 2488 : fold_scalar_for_access_diagram (range.get_size ()));
539 : }
540 :
541 : symbolic_bit_range
542 1916 : folded_symbolic_bit_range (const symbolic_bit_offset &start_offset,
543 : const symbolic_bit_size &size)
544 : {
545 1916 : return fold_range_for_access_diagram
546 1916 : (symbolic_bit_range (start_offset, size));
547 : }
548 :
549 : template<typename ConcreteValueType>
550 : bool
551 727 : symbolic::range<ConcreteValueType>::
552 : access_range_contains_p (const symbolic::range<ConcreteValueType> &other) const
553 : {
554 727 : return (get_start_offset () <= other.get_start_offset ()
555 1287 : && other.get_next_offset () <= get_next_offset ());
556 : }
557 :
558 : /* struct access_operation. */
559 :
560 : symbolic_bit_range
561 1369 : access_operation::get_valid_bits () const
562 : {
563 1369 : auto &capacity
564 1369 : = m_model.get_capacity_as_scalar (&m_attempted_range.get_base_region ());
565 1369 : auto *rmm = m_model.get_manager ();
566 1369 : auto &bit_mgr = rmm->get_node_manager ().get_scalars ().get_bits ();
567 1369 : return folded_symbolic_bit_range (bit_mgr.get_concrete (0_bits),
568 1369 : bits_from_bytes (capacity));
569 : }
570 :
571 : symbolic_bit_range
572 572 : access_operation::get_actual_bits () const
573 : {
574 572 : return fold_range_for_access_diagram (m_attempted_range.get_bit_range ());
575 : }
576 :
577 : /* If there are any bits accessed invalidly before the valid range,
578 : return true and write their range to *OUT.
579 : Return false if there aren't, or if there's a problem
580 : (e.g. symbolic ranges. */
581 :
582 : bool
583 136 : access_operation::maybe_get_invalid_before_bits (symbolic_bit_range *out) const
584 : {
585 136 : symbolic_bit_range valid_bits (get_valid_bits ());
586 136 : symbolic_bit_range actual_bits (get_actual_bits ());
587 :
588 136 : if (actual_bits.get_start_offset () >= valid_bits.get_start_offset ())
589 : {
590 : /* No part of accessed range is before the valid range. */
591 : return false;
592 : }
593 30 : else if (actual_bits.get_next_offset () > valid_bits.get_start_offset ())
594 : {
595 : /* Get part of accessed range that's before the valid range. */
596 16 : *out = folded_symbolic_bit_range (actual_bits.get_start_offset (),
597 : (valid_bits.get_start_offset ()
598 8 : - actual_bits.get_start_offset ()));
599 8 : return true;
600 : }
601 : else
602 : {
603 : /* Accessed range is fully before valid range. */
604 22 : *out = actual_bits;
605 22 : return true;
606 : }
607 : }
608 :
609 : /* If there are any bits accessed invalidly after the valid range,
610 : return true and write their range to *OUT.
611 : Return false if there aren't, or if there's a problem. */
612 :
613 : bool
614 136 : access_operation::maybe_get_invalid_after_bits (symbolic_bit_range *out) const
615 : {
616 136 : symbolic_bit_range valid_bits (get_valid_bits ());
617 136 : symbolic_bit_range actual_bits (get_actual_bits ());
618 :
619 136 : if (actual_bits.get_next_offset () <= valid_bits.get_next_offset ())
620 : {
621 : /* No part of accessed range is after the valid range. */
622 : return false;
623 : }
624 114 : else if (actual_bits.get_start_offset () < valid_bits.get_next_offset ())
625 : {
626 : /* Get part of accessed range that's after the valid range. */
627 56 : *out = folded_symbolic_bit_range (valid_bits.get_next_offset (),
628 : actual_bits.get_next_offset ()
629 56 : - valid_bits.get_next_offset ());
630 56 : return true;
631 : }
632 : else
633 : {
634 : /* Accessed range is fully after valid range. */
635 58 : *out = actual_bits;
636 58 : return true;
637 : }
638 : }
639 :
640 : /* A class for capturing all of the region offsets of interest (both concrete
641 : and symbolic), to help align everything in the diagram.
642 : Boundaries can be soft or hard; hard boundaries are emphasized visually
643 : (e.g. the boundary between valid vs invalid accesses).
644 :
645 : Offsets in the boundaries are all expressed relative to the base
646 : region of the access_operation. */
647 :
648 : class boundaries
649 : {
650 : public:
651 : struct comparator
652 : {
653 8697 : bool operator() (const symbolic_bit_offset *lhs,
654 : const symbolic_bit_offset *rhs) const
655 : {
656 8697 : if (lhs == rhs)
657 : return false;
658 :
659 6863 : if (auto *conc_lhs = lhs->dyn_cast_concrete_scalar ())
660 : {
661 6269 : if (auto *conc_rhs = rhs->dyn_cast_concrete_scalar ())
662 : /* Concrete vs concrete. */
663 6159 : return conc_lhs->get_concrete () < conc_rhs->get_concrete ();
664 : else
665 : {
666 : /* Concrete vs symbolic: put all concrete before all symbolic. */
667 : return true;
668 : }
669 : }
670 : else
671 : {
672 594 : if (rhs->dyn_cast_concrete_scalar ())
673 : {
674 : /* Symbolic vs concrete: put all symbolic after all concrete. */
675 : return false;
676 : }
677 : else
678 : {
679 : /* Symbolic vs symbolic. */
680 345 : return *lhs < *rhs;
681 : }
682 : }
683 : }
684 : };
685 :
686 : using offset_set = std::set<const symbolic_bit_offset *,
687 : comparator>;
688 :
689 : enum class kind { HARD, SOFT};
690 :
691 68 : boundaries (symbolic::node_manager &node_mgr,
692 : const region &base_reg,
693 : logger *logger)
694 68 : : m_base_reg (base_reg),
695 68 : m_node_mgr (node_mgr),
696 68 : m_logger (logger)
697 : {
698 : }
699 :
700 837 : void add (const symbolic_bit_offset &offset, enum kind k)
701 : {
702 837 : m_all_offsets.insert (&offset);
703 837 : if (k == kind::HARD)
704 352 : m_hard_offsets.insert (&offset);
705 837 : }
706 :
707 323 : void add (const concrete_bit_offset &offset, enum kind k)
708 : {
709 323 : auto &bit_mgr = m_node_mgr.get_scalars ().get_bits ();
710 323 : auto &sym = symbolic_from_concrete (offset, bit_mgr);
711 323 : add (sym, k);
712 323 : }
713 :
714 257 : void add (const symbolic_bit_range &range, enum kind kind)
715 : {
716 257 : add (range.get_start_offset (), kind);
717 257 : add (range.get_next_offset (), kind);
718 257 : if (m_logger)
719 : {
720 0 : m_logger->start_log_line ();
721 0 : m_logger->log_partial ("added symbolic_bit_range: ");
722 0 : range.dump_inline_to_pp (m_logger->get_printer ());
723 0 : m_logger->log_partial (" (%s)",
724 : (kind == boundaries::kind::HARD)
725 : ? "HARD" : "soft");
726 0 : m_logger->end_log_line ();
727 : }
728 257 : }
729 :
730 68 : void add (const region ®, region_model_manager *mgr, enum kind kind)
731 : {
732 68 : add (reg.get_memory_range (*mgr).get_bit_range (),
733 : kind);
734 68 : }
735 :
736 42 : void add_all_bytes_in_range (const concrete_byte_range &bytes)
737 : {
738 42 : for (concrete_byte_offset byte_idx = bytes.get_start_offset ();
739 365 : byte_idx <= bytes.get_next_offset ();
740 323 : byte_idx += 1_byte)
741 323 : add (bits_from_bytes (byte_idx), kind::SOFT);
742 42 : }
743 :
744 18 : void add_all_bytes_in_range (const symbolic_bit_range &range)
745 : {
746 18 : concrete_bit_range conc_bit_range;
747 18 : bool was_concrete = concrete_from_symbolic (range, &conc_bit_range);
748 18 : gcc_assert (was_concrete);
749 18 : concrete_byte_range conc_byte_range;
750 18 : bool valid = maybe_bytes_from_bits (conc_bit_range, &conc_byte_range);
751 18 : gcc_assert (valid);
752 18 : add_all_bytes_in_range (conc_byte_range);
753 18 : }
754 :
755 0 : void log (logger &logger) const
756 : {
757 0 : logger.log ("boundaries:");
758 0 : logger.inc_indent ();
759 0 : for (auto offset : m_all_offsets)
760 : {
761 0 : enum kind k = get_kind (*offset);
762 0 : logger.start_log_line ();
763 0 : logger.log_partial ("%s: ", (k == kind::HARD) ? "HARD" : "soft");
764 0 : offset->dump_to_pp (logger.get_printer (), true);
765 0 : logger.end_log_line ();
766 : }
767 0 : logger.dec_indent ();
768 0 : }
769 :
770 : enum kind
771 379 : get_kind (const symbolic::scalar<integer_with_unit<units::bit>> &offset) const
772 : {
773 379 : gcc_assert (m_all_offsets.find (&offset) != m_all_offsets.end ());
774 379 : if (m_hard_offsets.find (&offset) != m_hard_offsets.end ())
775 : return kind::HARD;
776 : else
777 282 : return kind::SOFT;
778 : }
779 :
780 68 : offset_set::const_iterator begin () const
781 : {
782 68 : return m_all_offsets.begin ();
783 : }
784 68 : offset_set::const_iterator end () const
785 : {
786 68 : return m_all_offsets.end ();
787 : }
788 : offset_set::size_type size () const
789 : {
790 : return m_all_offsets.size ();
791 : }
792 :
793 : std::vector<const symbolic_bit_offset *>
794 21 : get_hard_boundaries_in_range (concrete_byte_offset min_offset,
795 : concrete_byte_offset max_offset) const
796 : {
797 21 : std::vector<const symbolic_bit_offset *> result;
798 99 : for (auto &offset : m_hard_offsets)
799 : {
800 78 : concrete_bit_offset conc_bit;
801 78 : if (!concrete_from_symbolic (*offset, &conc_bit))
802 0 : continue;
803 78 : concrete_byte_offset conc_byte;
804 78 : if (!maybe_bytes_from_bits (conc_bit, &conc_byte))
805 0 : continue;
806 78 : if (conc_byte < min_offset)
807 4 : continue;
808 74 : if (conc_byte > max_offset)
809 42 : continue;
810 32 : result.push_back (offset);
811 124 : }
812 21 : return result;
813 : }
814 :
815 : private:
816 : const region &m_base_reg;
817 : symbolic::node_manager &m_node_mgr;
818 : logger *m_logger;
819 : offset_set m_all_offsets;
820 : offset_set m_hard_offsets;
821 : };
822 :
823 : /* A widget that wraps a table but offloads column-width calculation
824 : to a shared object, so that we can vertically line up multiple tables
825 : and have them all align their columns.
826 :
827 : For example, in:
828 :
829 : 01| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
830 : 02| |[0]|[1]|[2]|[3]|[4]|[5]| ... |[440]|[441]|[442]|[443]|[444]|[445]|
831 : 03| +---+---+---+---+---+---+ +-----+-----+-----+-----+-----+-----+
832 : 04| |'L'|'o'|'r'|'e'|'m'|' '| | 'o' | 'r' | 'u' | 'm' | '.' | NUL |
833 : 05| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
834 : 06| | string literal (type: 'char[446]') |
835 : 07| +----------------------------------------------------------------------+
836 : 08| | | | | | | | | | | | | | | |
837 : 09| | | | | | | | | | | | | | | |
838 : 10| v v v v v v v v v v v v v v v
839 : 11|+---+---------------------+----++--------------------------------------+
840 : 12||[0]| ... |[99]|| after valid range |
841 : 13|+---+---------------------+----+| |
842 : 14|| 'buf' (type: 'char[100]') || |
843 : 15|+------------------------------++--------------------------------------+
844 : 16||~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~||~~~~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~~~~|
845 : 17| | |
846 : 18| +---------+---------+ +----------+----------+
847 : 19| |capacity: 100 bytes| |overflow of 346 bytes|
848 : 20| +-------------------+ +---------------------+
849 :
850 : rows 01-07 and rows 11-15 are x_aligned_table_widget instances. */
851 :
852 : class x_aligned_table_widget : public leaf_widget
853 : {
854 : public:
855 137 : x_aligned_table_widget (table t,
856 : const theme &theme,
857 : table_dimension_sizes &col_widths)
858 137 : : m_table (std::move (t)),
859 137 : m_theme (theme),
860 137 : m_col_widths (col_widths),
861 137 : m_row_heights (t.get_size ().h),
862 137 : m_cell_sizes (m_col_widths, m_row_heights),
863 274 : m_tg (m_table, m_cell_sizes)
864 : {
865 137 : }
866 :
867 0 : const char *get_desc () const override
868 : {
869 0 : return "x_aligned_table_widget";
870 : }
871 :
872 137 : canvas::size_t calc_req_size () final override
873 : {
874 : /* We don't compute the size requirements;
875 : the parent should have done this. */
876 137 : return m_tg.get_canvas_size ();
877 : }
878 :
879 137 : void paint_to_canvas (canvas &canvas) final override
880 : {
881 137 : m_table.paint_to_canvas (canvas,
882 137 : get_top_left (),
883 137 : m_tg,
884 : m_theme);
885 137 : }
886 :
887 274 : const table &get_table () const { return m_table; }
888 274 : table_cell_sizes &get_cell_sizes () { return m_cell_sizes; }
889 137 : void recalc_coords ()
890 : {
891 137 : m_tg.recalc_coords ();
892 : }
893 :
894 : private:
895 : table m_table;
896 : const theme &m_theme;
897 : table_dimension_sizes &m_col_widths; // Reference to shared column widths
898 : table_dimension_sizes m_row_heights; // Unique row heights
899 : table_cell_sizes m_cell_sizes;
900 : table_geometry m_tg;
901 : };
902 :
903 : /* A widget for printing arrows between the accessed region
904 : and the svalue, showing the direction of the access.
905 :
906 : For example, in:
907 :
908 : 01| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
909 : 02| |[0]|[1]|[2]|[3]|[4]|[5]| ... |[440]|[441]|[442]|[443]|[444]|[445]|
910 : 03| +---+---+---+---+---+---+ +-----+-----+-----+-----+-----+-----+
911 : 04| |'L'|'o'|'r'|'e'|'m'|' '| | 'o' | 'r' | 'u' | 'm' | '.' | NUL |
912 : 05| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
913 : 06| | string literal (type: 'char[446]') |
914 : 07| +----------------------------------------------------------------------+
915 : 08| | | | | | | | | | | | | | | |
916 : 09| | | | | | | | | | | | | | | |
917 : 10| v v v v v v v v v v v v v v v
918 : 11|+---+---------------------+----++--------------------------------------+
919 : 12||[0]| ... |[99]|| after valid range |
920 : 13|+---+---------------------+----+| |
921 : 14|| 'buf' (type: 'char[100]') || |
922 : 15|+------------------------------++--------------------------------------+
923 : 16||~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~||~~~~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~~~~|
924 : 17| | |
925 : 18| +---------+---------+ +----------+----------+
926 : 19| |capacity: 100 bytes| |overflow of 346 bytes|
927 : 20| +-------------------+ +---------------------+
928 :
929 : rows 8-10 are the direction widget. */
930 :
931 : class direction_widget : public leaf_widget
932 : {
933 : public:
934 68 : direction_widget (const access_diagram_impl &dia_impl,
935 : const bit_to_table_map &btm)
936 : : leaf_widget (),
937 68 : m_dia_impl (dia_impl),
938 68 : m_btm (btm)
939 : {
940 : }
941 0 : const char *get_desc () const override
942 : {
943 0 : return "direction_widget";
944 : }
945 68 : canvas::size_t calc_req_size () final override
946 : {
947 : /* Get our width from our siblings. */
948 68 : return canvas::size_t (0, 3);
949 : }
950 : void paint_to_canvas (canvas &canvas) final override;
951 :
952 : private:
953 : const access_diagram_impl &m_dia_impl;
954 : const bit_to_table_map &m_btm;
955 : };
956 :
957 : /* A widget for adding an x_ruler to a diagram based on table columns,
958 : offloading column-width calculation to shared objects, so that the ruler
959 : lines up with other tables in the diagram.
960 :
961 : For example, in:
962 :
963 : 01| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
964 : 02| |[0]|[1]|[2]|[3]|[4]|[5]| ... |[440]|[441]|[442]|[443]|[444]|[445]|
965 : 03| +---+---+---+---+---+---+ +-----+-----+-----+-----+-----+-----+
966 : 04| |'L'|'o'|'r'|'e'|'m'|' '| | 'o' | 'r' | 'u' | 'm' | '.' | NUL |
967 : 05| +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
968 : 06| | string literal (type: 'char[446]') |
969 : 07| +----------------------------------------------------------------------+
970 : 08| | | | | | | | | | | | | | | |
971 : 09| | | | | | | | | | | | | | | |
972 : 10| v v v v v v v v v v v v v v v
973 : 11|+---+---------------------+----++--------------------------------------+
974 : 12||[0]| ... |[99]|| after valid range |
975 : 13|+---+---------------------+----+| |
976 : 14|| 'buf' (type: 'char[100]') || |
977 : 15|+------------------------------++--------------------------------------+
978 : 16||~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~||~~~~~~~~~~~~~~~~~~+~~~~~~~~~~~~~~~~~~~|
979 : 17| | |
980 : 18| +---------+---------+ +----------+----------+
981 : 19| |capacity: 100 bytes| |overflow of 346 bytes|
982 : 20| +-------------------+ +---------------------+
983 :
984 : rows 16-20 are the x_aligned_x_ruler_widget. */
985 :
986 : class x_aligned_x_ruler_widget : public leaf_widget
987 : {
988 : public:
989 68 : x_aligned_x_ruler_widget (const access_diagram_impl &dia_impl,
990 : const theme &theme)
991 68 : : m_dia_impl (dia_impl),
992 68 : m_theme (theme)
993 : {
994 : }
995 :
996 0 : const char *get_desc () const override
997 : {
998 0 : return "x_aligned_ruler_widget";
999 : }
1000 :
1001 150 : void add_range (const table::range_t &x_range,
1002 : styled_string text,
1003 : style::id_t style_id)
1004 : {
1005 150 : m_labels.push_back (label (x_range, std::move (text), style_id));
1006 150 : }
1007 :
1008 68 : canvas::size_t calc_req_size () final override
1009 : {
1010 68 : x_ruler r (make_x_ruler ());
1011 68 : return r.get_size ();
1012 68 : }
1013 :
1014 68 : void paint_to_canvas (canvas &canvas) final override
1015 : {
1016 68 : x_ruler r (make_x_ruler ());
1017 68 : r.paint_to_canvas (canvas,
1018 68 : get_top_left (),
1019 : m_theme);
1020 68 : }
1021 :
1022 : private:
1023 546 : struct label
1024 : {
1025 150 : label (const table::range_t &table_x_range,
1026 : styled_string text,
1027 : style::id_t style_id)
1028 150 : : m_table_x_range (table_x_range),
1029 150 : m_text (std::move (text)),
1030 150 : m_style_id (style_id)
1031 : {
1032 : }
1033 : table::range_t m_table_x_range;
1034 : styled_string m_text;
1035 : style::id_t m_style_id;
1036 : };
1037 :
1038 : x_ruler make_x_ruler () const;
1039 :
1040 : const access_diagram_impl &m_dia_impl;
1041 : const theme &m_theme;
1042 : std::vector<label> m_labels;
1043 : };
1044 :
1045 : /* A two-way mapping between symbolic_bit_ranges and table columns, for use by
1046 : spatial_item subclasses for creating tables.
1047 : For example when visualizing a bogus access of 'int arr[10];'
1048 : at 'arr[10]', we might have:
1049 : - table column 0 is "bytes 0-3" (for arr[0])
1050 : - table column 1 is "bytes 4-35" (for arr[1] through arr[8])
1051 : - table column 2 is "bytes 36-39 (for arr[9])
1052 : - table column 3 is blank to emphasize a hard boundary between
1053 : valid/invalid accesses.
1054 : - table column 4 is "bytes 40-44" (for arr[10])
1055 :
1056 : We store this as a pair of maps from symbolic_bit_offset * to table x; in
1057 : the abvove example:
1058 :
1059 : region offset table_x prev_table_x
1060 : bit 0 (aka byte 0) 0 (none)
1061 : bit 32 (aka byte 4) 1 0
1062 : bit 288 (aka byte 36) 2 1
1063 : bit 320 (aka byte 40) 4 2
1064 : bit 352 (aka byte 44) (none) (none)
1065 :
1066 : so that e.g given the half-open byte range [0, 40)
1067 : we can determine the closed range of table x [0, 2]. */
1068 :
1069 : class bit_to_table_map
1070 : {
1071 : public:
1072 68 : bit_to_table_map (symbolic::node_manager &node_mgr)
1073 68 : : m_node_mgr (node_mgr)
1074 : {
1075 : }
1076 :
1077 : /* Populate m_table_x_for_bit and m_bit_for_table_x. */
1078 68 : void populate (const boundaries &boundaries,
1079 : logger *logger)
1080 : {
1081 68 : LOG_SCOPE (logger);
1082 :
1083 68 : int table_x = 0;
1084 68 : std::vector <const symbolic_bit_offset *> vec_boundaries
1085 : (boundaries.begin (),
1086 68 : boundaries.end ());
1087 :
1088 : /* Sort into an order that makes sense. */
1089 68 : std::sort (vec_boundaries.begin (),
1090 : vec_boundaries.end (),
1091 : boundaries::comparator ());
1092 :
1093 68 : if (logger)
1094 : {
1095 0 : logger->log ("vec_boundaries");
1096 0 : logger->inc_indent ();
1097 0 : for (unsigned idx = 0; idx < vec_boundaries.size (); idx++)
1098 : {
1099 0 : logger->start_log_line ();
1100 0 : logger->log_partial ("idx: %i: ", idx);
1101 0 : vec_boundaries[idx]->dump_to_pp (logger->get_printer (), true);
1102 0 : logger->end_log_line ();
1103 : }
1104 0 : logger->dec_indent ();
1105 : }
1106 :
1107 583 : for (size_t idx = 0; idx < vec_boundaries.size (); idx++)
1108 : {
1109 515 : const symbolic_bit_offset &offset = *vec_boundaries[idx];
1110 515 : if (idx > 0 && (idx + 1) < vec_boundaries.size ())
1111 : {
1112 379 : if (boundaries.get_kind (offset) == boundaries::kind::HARD)
1113 97 : table_x += 1;
1114 : }
1115 515 : m_table_x_for_offset[&offset] = table_x;
1116 515 : if ((idx + 1) < vec_boundaries.size ())
1117 : {
1118 447 : const symbolic_bit_offset &next_offset = *vec_boundaries[idx + 1];
1119 447 : m_table_x_for_prev_offset[&next_offset] = table_x;
1120 894 : m_range_for_table_x[table_x]
1121 894 : = folded_symbolic_bit_range (offset, next_offset - offset);
1122 : }
1123 515 : table_x += 1;
1124 : }
1125 68 : m_num_columns = table_x - 1;
1126 :
1127 68 : if (logger)
1128 0 : log (*logger);
1129 68 : }
1130 :
1131 1848 : unsigned get_num_columns () const
1132 : {
1133 1848 : return m_num_columns;
1134 : }
1135 :
1136 1088 : table::range_t get_table_x_for_range (const symbolic_bit_range &range) const
1137 : {
1138 2176 : return table::range_t (get_table_x_for_offset (range.get_start_offset ()),
1139 1088 : get_table_x_for_prev_offset (range.get_next_offset ()) + 1);
1140 : }
1141 :
1142 734 : table::rect_t get_table_rect (const symbolic_bit_range &range,
1143 : const int table_y, const int table_h) const
1144 : {
1145 734 : const table::range_t x_range (get_table_x_for_range (range));
1146 734 : return table::rect_t (table::coord_t (x_range.start, table_y),
1147 734 : table::size_t (x_range.get_size (), table_h));
1148 : }
1149 :
1150 543 : table::rect_t get_table_rect (const concrete_bit_range &bits,
1151 : const int table_y, const int table_h) const
1152 : {
1153 543 : auto &bit_mgr = m_node_mgr.get_scalars ().get_bits ();
1154 543 : const symbolic_bit_range range (symbolic_from_concrete (bits, bit_mgr));
1155 543 : return get_table_rect (range, table_y, table_h);
1156 : }
1157 :
1158 543 : table::rect_t get_table_rect (const concrete_byte_range &bytes,
1159 : const int table_y, const int table_h) const
1160 : {
1161 1086 : return get_table_rect (bits_from_bytes (bytes), table_y, table_h);
1162 : }
1163 :
1164 1093 : bool maybe_get_symbolic_bit_range_for_table_x (int table_x,
1165 : symbolic_bit_range *out) const
1166 : {
1167 1093 : auto slot = m_range_for_table_x.find (table_x);
1168 1093 : if (slot == m_range_for_table_x.end ())
1169 : return false;
1170 898 : *out = slot->second;
1171 898 : return true;
1172 : }
1173 :
1174 0 : void log (logger &logger) const
1175 : {
1176 0 : logger.log ("table columns");
1177 0 : logger.inc_indent ();
1178 0 : for (unsigned table_x = 0; table_x < get_num_columns (); table_x++)
1179 : {
1180 0 : logger.start_log_line ();
1181 0 : logger.log_partial ("table_x: %i", table_x);
1182 0 : symbolic_bit_range range_for_column;
1183 0 : if (maybe_get_symbolic_bit_range_for_table_x (table_x,
1184 : &range_for_column))
1185 : {
1186 0 : logger.log_partial (": range: ");
1187 0 : range_for_column.dump_inline_to_pp (logger.get_printer ());
1188 : }
1189 0 : logger.end_log_line ();
1190 : }
1191 0 : logger.dec_indent ();
1192 0 : }
1193 :
1194 1120 : int get_table_x_for_offset (const symbolic_bit_offset &offset) const
1195 : {
1196 1120 : auto slot = m_table_x_for_offset.find (&offset);
1197 :
1198 : /* If this fails, then we probably failed to fully populate m_boundaries
1199 : in find_boundaries. */
1200 1120 : gcc_assert (slot != m_table_x_for_offset.end ());
1201 :
1202 1120 : return slot->second;
1203 : }
1204 :
1205 : private:
1206 1088 : int get_table_x_for_prev_offset (const symbolic_bit_offset &offset) const
1207 : {
1208 1088 : auto slot = m_table_x_for_prev_offset.find (&offset);
1209 :
1210 : /* If this fails, then we probably failed to fully populate m_boundaries
1211 : in find_boundaries. */
1212 1088 : gcc_assert (slot != m_table_x_for_prev_offset.end ());
1213 :
1214 1088 : return slot->second;
1215 : }
1216 :
1217 : symbolic::node_manager &m_node_mgr;
1218 : std::map<const symbolic_bit_offset *, int> m_table_x_for_offset;
1219 : std::map<const symbolic_bit_offset *, int> m_table_x_for_prev_offset;
1220 : std::map<int, symbolic_bit_range> m_range_for_table_x;
1221 : unsigned m_num_columns;
1222 : };
1223 :
1224 : /* Base class for something in the diagram that participates
1225 : in two steps of diagram creation:
1226 : (a) populating a boundaries instance with the boundaries of interest
1227 : (b) creating a table instance for itself.
1228 :
1229 : Offsets in the boundaries are all expressed relative to the base
1230 : region of the access_operation. */
1231 :
1232 242 : class spatial_item
1233 : {
1234 : public:
1235 : virtual ~spatial_item () {}
1236 : virtual void add_boundaries (boundaries &out, logger *) const = 0;
1237 :
1238 : virtual table make_table (const bit_to_table_map &btm,
1239 : style_manager &sm) const = 0;
1240 : };
1241 :
1242 : /* A spatial_item that involves showing an svalue at a particular offset. */
1243 :
1244 : class svalue_spatial_item : public spatial_item
1245 : {
1246 : public:
1247 : enum class kind
1248 : {
1249 : WRITTEN,
1250 : EXISTING
1251 : };
1252 : protected:
1253 83 : svalue_spatial_item (const svalue &sval,
1254 : symbolic_bit_range bit_range,
1255 : enum kind kind)
1256 83 : : m_sval (sval), m_bit_range (bit_range), m_kind (kind)
1257 : {
1258 : }
1259 :
1260 : const svalue &m_sval;
1261 : symbolic_bit_range m_bit_range;
1262 : enum kind m_kind;
1263 : };
1264 :
1265 : static std::unique_ptr<spatial_item>
1266 : make_existing_svalue_spatial_item (const svalue *sval,
1267 : const symbolic_bit_range &bit_range,
1268 : const theme &theme);
1269 :
1270 : class svalue_from_bit_vector_spatial_item : public svalue_spatial_item
1271 : {
1272 : public:
1273 53 : svalue_from_bit_vector_spatial_item (const svalue_from_bit_vector &sval,
1274 : const symbolic_bit_range &bit_range,
1275 : enum kind kind,
1276 : const theme &theme)
1277 : : svalue_spatial_item (sval, bit_range, kind),
1278 53 : m_bv (sval.get_bit_vector ())
1279 : {
1280 53 : add_children_for_bit_vector (m_bv, bit_range, theme);
1281 53 : }
1282 :
1283 53 : void add_boundaries (boundaries &out, logger *logger) const final override
1284 : {
1285 53 : LOG_SCOPE (logger);
1286 64 : for (auto &iter : m_children)
1287 11 : iter->add_boundaries (out, logger);
1288 53 : }
1289 :
1290 53 : table make_table (const bit_to_table_map &btm,
1291 : style_manager &sm) const final override
1292 : {
1293 53 : std::vector<table> child_tables;
1294 53 : int max_rows = 0;
1295 64 : for (auto &iter : m_children)
1296 : {
1297 11 : table child_table (iter->make_table (btm, sm));
1298 11 : max_rows = MAX (max_rows, child_table.get_size ().h);
1299 11 : child_tables.push_back (std::move (child_table));
1300 11 : }
1301 53 : table t (table::size_t (btm.get_num_columns (), max_rows));
1302 64 : for (auto &&child_table : child_tables)
1303 11 : t.add_other_table (std::move (child_table),
1304 11 : table::coord_t (0, 0));
1305 106 : return t;
1306 53 : }
1307 :
1308 : private:
1309 : /* Recursively populate m_children from BV at BIT_RANGE. */
1310 : void
1311 79 : add_children_for_bit_vector (const symbolic::bit_vector &bv,
1312 : const symbolic_bit_range &bit_range,
1313 : const theme &theme)
1314 : {
1315 79 : switch (bv.get_kind ())
1316 : {
1317 0 : default:
1318 0 : gcc_unreachable ();
1319 :
1320 11 : case symbolic::bit_vector::kind::concat:
1321 11 : {
1322 11 : auto &concat_bv = (const symbolic::concat_bit_vector &)bv;
1323 11 : const symbolic_bit_offset *iter_start_offset
1324 11 : = &bit_range.get_start_offset ();
1325 37 : for (auto iter : concat_bv)
1326 : {
1327 26 : add_children_for_bit_vector
1328 26 : (*iter,
1329 26 : folded_symbolic_bit_range (*iter_start_offset,
1330 : iter->get_size ()),
1331 : theme);
1332 26 : iter_start_offset = &(*iter_start_offset + iter->get_size ());
1333 : }
1334 : }
1335 : break;
1336 :
1337 :
1338 : case symbolic::bit_vector::kind::conjured:
1339 : break;
1340 : case symbolic::bit_vector::kind::cropped:
1341 : break;
1342 0 : case symbolic::bit_vector::kind::empty:
1343 0 : gcc_unreachable ();
1344 : break;
1345 : case symbolic::bit_vector::kind::named_test:
1346 : break;
1347 : case symbolic::bit_vector::kind::poisoned:
1348 : break;
1349 : case symbolic::bit_vector::kind::repeated:
1350 : break;
1351 11 : case symbolic::bit_vector::kind::svalue:
1352 11 : {
1353 11 : auto &sval_bv
1354 : = (const symbolic::bit_vector_from_svalue &)bv;
1355 11 : auto child
1356 11 : = make_existing_svalue_spatial_item (&sval_bv.get_svalue (),
1357 : bit_range,
1358 11 : theme);
1359 11 : if (child)
1360 11 : m_children.push_back (std::move (child));
1361 11 : }
1362 11 : break;
1363 : case symbolic::bit_vector::kind::from_ubc:
1364 : break;
1365 : case symbolic::bit_vector::kind::tristate:
1366 : break;
1367 : }
1368 79 : }
1369 :
1370 : const symbolic::bit_vector &m_bv;
1371 : std::vector<std::unique_ptr<spatial_item>> m_children;
1372 : };
1373 :
1374 : /* Loop through the TABLE_X_RANGE columns of T, adding
1375 : cells containing "..." in any unoccupied ranges of table cell. */
1376 :
1377 : static void
1378 34 : add_ellipsis_to_gaps (table &t,
1379 : style_manager &sm,
1380 : const table::range_t &table_x_range,
1381 : const table::range_t &table_y_range)
1382 : {
1383 34 : int table_x = table_x_range.get_min ();
1384 76 : while (table_x < table_x_range.get_next ())
1385 : {
1386 : /* Find a run of unoccupied table cells. */
1387 : const int start_table_x = table_x;
1388 236 : while (table_x < table_x_range.get_next ()
1389 236 : && !t.get_placement_at (table::coord_t (table_x,
1390 205 : table_y_range.get_min ())))
1391 194 : table_x++;
1392 42 : const table::range_t unoccupied_x_range (start_table_x, table_x);
1393 42 : if (unoccupied_x_range.get_size () > 0)
1394 42 : t.set_cell_span (table::rect_t (unoccupied_x_range, table_y_range),
1395 84 : styled_string (sm, "..."));
1396 : /* Skip occupied table cells. */
1397 53 : while (table_x < table_x_range.get_next ()
1398 53 : && t.get_placement_at (table::coord_t (table_x,
1399 21 : table_y_range.get_min ())))
1400 11 : table_x++;
1401 : }
1402 34 : }
1403 :
1404 : /* Subclass of spatial_item for visualizing the region of memory
1405 : that's valid to access relative to the base region of region accessed in
1406 : the operation. */
1407 :
1408 : class valid_region_spatial_item : public spatial_item
1409 : {
1410 : public:
1411 68 : valid_region_spatial_item (const access_operation &op,
1412 : diagnostics::paths::event_id_t region_creation_event_id,
1413 : const theme &theme)
1414 68 : : m_op (op),
1415 68 : m_region_creation_event_id (region_creation_event_id),
1416 68 : m_boundaries (nullptr),
1417 136 : m_existing_sval (op.m_model.get_store_value (&op.get_base_region (), nullptr)),
1418 68 : m_existing_sval_spatial_item
1419 : (make_existing_svalue_spatial_item (m_existing_sval,
1420 68 : op.get_valid_bits (),
1421 68 : theme))
1422 : {
1423 68 : }
1424 :
1425 68 : void add_boundaries (boundaries &out, logger *logger) const final override
1426 : {
1427 68 : LOG_SCOPE (logger);
1428 68 : m_boundaries = &out;
1429 68 : symbolic_bit_range valid_bits = m_op.get_valid_bits ();
1430 68 : if (logger)
1431 : {
1432 0 : logger->start_log_line ();
1433 0 : logger->log_partial ("valid bits: ");
1434 0 : valid_bits.dump_inline_to_pp (logger->get_printer ());
1435 0 : logger->end_log_line ();
1436 : }
1437 68 : out.add (valid_bits, boundaries::kind::HARD);
1438 :
1439 68 : if (m_existing_sval_spatial_item)
1440 : {
1441 55 : if (logger)
1442 : {
1443 0 : logger->start_log_line ();
1444 0 : logger->log_partial ("existing svalue: ");
1445 0 : m_existing_sval->dump_to_pp (logger->get_printer (), true);
1446 0 : logger->end_log_line ();
1447 : }
1448 55 : m_existing_sval_spatial_item->add_boundaries (out, logger);
1449 : }
1450 :
1451 : /* Support for showing first and final element in array types. */
1452 68 : if (tree base_type = m_op.get_base_region ().get_type ())
1453 35 : if (TREE_CODE (base_type) == ARRAY_TYPE)
1454 : {
1455 35 : if (logger)
1456 0 : logger->log ("showing first and final element in array type");
1457 35 : region_model_manager *mgr = m_op.m_model.get_manager ();
1458 35 : tree domain = TYPE_DOMAIN (base_type);
1459 35 : if (domain && TYPE_MIN_VALUE (domain) && TYPE_MAX_VALUE (domain))
1460 : {
1461 34 : const svalue *min_idx_sval
1462 34 : = mgr->get_or_create_constant_svalue (TYPE_MIN_VALUE (domain));
1463 34 : const svalue *max_idx_sval
1464 34 : = mgr->get_or_create_constant_svalue (TYPE_MAX_VALUE (domain));
1465 34 : const region *min_element =
1466 34 : mgr->get_element_region (&m_op.get_base_region (),
1467 34 : TREE_TYPE (base_type),
1468 : min_idx_sval);
1469 34 : out.add (*min_element, mgr, boundaries::kind::SOFT);
1470 34 : const region *max_element =
1471 34 : mgr->get_element_region (&m_op.get_base_region (),
1472 34 : TREE_TYPE (base_type),
1473 : max_idx_sval);
1474 34 : out.add (*max_element, mgr, boundaries::kind::SOFT);
1475 : }
1476 : }
1477 68 : }
1478 :
1479 : /* Subroutine of make_table when base region has ARRAY_TYPE. */
1480 35 : void add_array_elements_to_table (table &t,
1481 : const bit_to_table_map &btm,
1482 : style_manager &sm) const
1483 : {
1484 35 : tree base_type = m_op.get_base_region ().get_type ();
1485 35 : gcc_assert (TREE_CODE (base_type) == ARRAY_TYPE);
1486 35 : gcc_assert (m_boundaries != nullptr);
1487 :
1488 35 : tree domain = TYPE_DOMAIN (base_type);
1489 35 : if (!(domain && TYPE_MIN_VALUE (domain) && TYPE_MAX_VALUE (domain)))
1490 1 : return;
1491 :
1492 34 : const int table_y = 0;
1493 34 : const int table_h = 1;
1494 34 : const table::range_t table_y_range (table_y, table_y + table_h);
1495 :
1496 34 : t.add_row ();
1497 :
1498 34 : const table::range_t min_x_range
1499 34 : = maybe_add_array_index_to_table (t, btm, sm, table_y_range,
1500 34 : TYPE_MIN_VALUE (domain));
1501 34 : const table::range_t max_x_range
1502 34 : = maybe_add_array_index_to_table (t, btm, sm, table_y_range,
1503 34 : TYPE_MAX_VALUE (domain));
1504 :
1505 34 : if (TREE_TYPE (base_type) == char_type_node)
1506 : {
1507 : /* For a char array,: if there are any hard boundaries in
1508 : m_boundaries that are *within* the valid region,
1509 : then show those index values. */
1510 21 : std::vector<const symbolic_bit_offset *> hard_boundaries
1511 21 : = m_boundaries->get_hard_boundaries_in_range
1512 42 : (concrete_byte_offset (convert_from_integer_cst (TYPE_MIN_VALUE (domain))),
1513 63 : concrete_byte_offset (convert_from_integer_cst (TYPE_MAX_VALUE (domain))));
1514 53 : for (auto &offset : hard_boundaries)
1515 : {
1516 32 : const int table_x = btm.get_table_x_for_offset (*offset);
1517 32 : concrete_bit_offset conc_bit;
1518 32 : if (!concrete_from_symbolic (*offset, &conc_bit))
1519 0 : continue;
1520 32 : concrete_byte_offset conc_byte;
1521 32 : if (!maybe_bytes_from_bits (conc_bit, &conc_byte))
1522 0 : continue;
1523 32 : table::range_t table_x_range (table_x, table_x + 1);
1524 32 : pp_element_integer e_conc_byte (conc_byte.get_integer ());
1525 32 : t.maybe_set_cell_span (table::rect_t (table_x_range,
1526 32 : table_y_range),
1527 64 : fmt_styled_string (sm, "[%e]",
1528 : &e_conc_byte));
1529 32 : }
1530 21 : }
1531 :
1532 34 : add_ellipsis_to_gaps (t, sm,
1533 34 : table::range_t (min_x_range.get_next (),
1534 34 : max_x_range.get_min ()),
1535 : table_y_range);
1536 : }
1537 :
1538 : table::range_t
1539 68 : maybe_add_array_index_to_table (table &t,
1540 : const bit_to_table_map &btm,
1541 : style_manager &sm,
1542 : const table::range_t table_y_range,
1543 : tree idx_cst) const
1544 : {
1545 68 : region_model_manager * const mgr = m_op.get_manager ();
1546 68 : tree base_type = m_op.get_base_region ().get_type ();
1547 68 : const svalue *idx_sval
1548 68 : = mgr->get_or_create_constant_svalue (idx_cst);
1549 68 : const region *element_reg = mgr->get_element_region (&m_op.get_base_region (),
1550 68 : TREE_TYPE (base_type),
1551 : idx_sval);
1552 68 : symbolic_bit_range element_range
1553 68 : = element_reg->get_memory_range (*mgr).get_bit_range ();
1554 68 : const table::range_t element_x_range
1555 68 : = btm.get_table_x_for_range (element_range);
1556 :
1557 68 : t.maybe_set_cell_span (table::rect_t (element_x_range,
1558 68 : table_y_range),
1559 136 : fmt_styled_string (sm, "[%E]", idx_cst));
1560 :
1561 68 : return element_x_range;
1562 : }
1563 :
1564 68 : table make_table (const bit_to_table_map &btm,
1565 : style_manager &sm) const final override
1566 : {
1567 68 : table t (table::size_t (btm.get_num_columns (), 0));
1568 :
1569 68 : if (tree base_type = m_op.get_base_region ().get_type ())
1570 35 : if (TREE_CODE (base_type) == ARRAY_TYPE)
1571 35 : add_array_elements_to_table (t, btm, sm);
1572 :
1573 : /* Make use of m_existing_sval_spatial_item, if any. */
1574 68 : if (m_existing_sval_spatial_item)
1575 : {
1576 55 : table table_for_existing
1577 55 : = m_existing_sval_spatial_item->make_table (btm, sm);
1578 55 : const int table_y = t.add_rows (table_for_existing.get_size ().h);
1579 55 : t.add_other_table (std::move (table_for_existing),
1580 55 : table::coord_t (0, table_y));
1581 55 : }
1582 :
1583 68 : symbolic_bit_range valid_bits = m_op.get_valid_bits ();
1584 68 : const int table_y = t.add_row ();
1585 68 : const int table_h = 1;
1586 68 : table::rect_t rect = btm.get_table_rect (valid_bits, table_y, table_h);
1587 68 : styled_string s;
1588 68 : switch (m_op.get_base_region ().get_kind ())
1589 : {
1590 0 : default:
1591 0 : s = styled_string (sm, _("region"));
1592 0 : break;
1593 33 : case RK_DECL:
1594 33 : {
1595 33 : const decl_region *decl_reg
1596 33 : = as_a <const decl_region *> (&m_op.get_base_region ());
1597 33 : tree decl = decl_reg->get_decl ();
1598 33 : s = fmt_styled_string (sm, "%qE (type: %qT)",
1599 : decl,
1600 66 : TREE_TYPE (decl));
1601 : }
1602 33 : break;
1603 21 : case RK_HEAP_ALLOCATED:
1604 21 : {
1605 21 : if (m_region_creation_event_id.known_p ())
1606 42 : s = fmt_styled_string (sm, _("buffer allocated on heap at %@"),
1607 21 : &m_region_creation_event_id);
1608 : else
1609 0 : s = styled_string (sm, _("heap-allocated buffer"));
1610 : }
1611 : break;
1612 12 : case RK_ALLOCA:
1613 12 : {
1614 12 : if (m_region_creation_event_id.known_p ())
1615 24 : s = fmt_styled_string (sm, _("buffer allocated on stack at %@"),
1616 12 : &m_region_creation_event_id);
1617 : else
1618 0 : s = styled_string (sm, _("stack-allocated buffer"));
1619 : }
1620 : break;
1621 2 : case RK_STRING:
1622 2 : {
1623 2 : const string_region *string_reg
1624 2 : = as_a <const string_region *> (&m_op.get_base_region ());
1625 2 : tree string_cst = string_reg->get_string_cst ();
1626 2 : s = fmt_styled_string (sm, _("string literal (type: %qT)"),
1627 4 : TREE_TYPE (string_cst));
1628 : }
1629 2 : break;
1630 : }
1631 68 : t.set_cell_span (rect, std::move (s));
1632 :
1633 68 : return t;
1634 68 : }
1635 :
1636 : private:
1637 : const access_operation &m_op;
1638 : diagnostics::paths::event_id_t m_region_creation_event_id;
1639 : mutable const boundaries *m_boundaries;
1640 : const svalue *m_existing_sval;
1641 : std::unique_ptr<spatial_item> m_existing_sval_spatial_item;
1642 : };
1643 :
1644 : /* Subclass of spatial_item for visualizing the region of memory
1645 : that's actually accessed by the read or write, for reads and
1646 : for write cases where we don't know the svalue written. */
1647 :
1648 : class accessed_region_spatial_item : public spatial_item
1649 : {
1650 : public:
1651 68 : accessed_region_spatial_item (const access_operation &op) : m_op (op) {}
1652 :
1653 68 : void add_boundaries (boundaries &out, logger *logger) const final override
1654 : {
1655 68 : LOG_SCOPE (logger);
1656 68 : symbolic_bit_range actual_bits = m_op.get_actual_bits ();
1657 68 : if (logger)
1658 : {
1659 0 : logger->start_log_line ();
1660 0 : logger->log_partial ("actual bits: ");
1661 0 : actual_bits.dump_inline_to_pp (logger->get_printer ());
1662 0 : logger->end_log_line ();
1663 : }
1664 68 : out.add (actual_bits, boundaries::kind::HARD);
1665 68 : }
1666 :
1667 28 : table make_table (const bit_to_table_map &btm,
1668 : style_manager &sm) const final override
1669 : {
1670 28 : table t (table::size_t (btm.get_num_columns (), 1));
1671 :
1672 28 : symbolic_bit_range actual_bits = m_op.get_actual_bits ();
1673 28 : const int table_y = 0;
1674 28 : const int table_h = 1;
1675 28 : table::rect_t rect = btm.get_table_rect (actual_bits, table_y, table_h);
1676 28 : t.set_cell_span (rect, styled_string (get_label_string (sm)));
1677 :
1678 28 : return t;
1679 : }
1680 :
1681 : private:
1682 28 : styled_string get_label_string (style_manager &sm) const
1683 : {
1684 28 : const symbolic_bit_range accessed_bits (m_op.get_actual_bits ());
1685 28 : return get_access_size_str (sm,
1686 : m_op,
1687 : accessed_bits,
1688 28 : m_op.get_base_region ().get_type ());
1689 : }
1690 :
1691 : const access_operation &m_op;
1692 : };
1693 :
1694 : /* Subclass of spatial_item for when we know the svalue being written
1695 : to the accessed region.
1696 : Can be subclassed to give visualizations of specific kinds of svalue. */
1697 :
1698 : class written_svalue_spatial_item : public spatial_item
1699 : {
1700 : public:
1701 23 : written_svalue_spatial_item (const access_operation &op,
1702 : const svalue &sval,
1703 : symbolic_bit_range actual_bits)
1704 23 : : m_op (op), m_sval (sval), m_actual_bits (actual_bits)
1705 : {}
1706 :
1707 23 : void add_boundaries (boundaries &out, logger *logger) const override
1708 : {
1709 23 : LOG_SCOPE (logger);
1710 23 : out.add (m_actual_bits, boundaries::kind::HARD);
1711 23 : }
1712 :
1713 23 : table make_table (const bit_to_table_map &btm,
1714 : style_manager &sm) const override
1715 : {
1716 23 : table t (table::size_t (btm.get_num_columns (), 0));
1717 :
1718 23 : const int table_y = t.add_row ();
1719 23 : const int table_h = 1;
1720 23 : table::rect_t rect = btm.get_table_rect (m_actual_bits, table_y, table_h);
1721 23 : t.set_cell_span (rect, styled_string (get_label_string (sm)));
1722 23 : return t;
1723 : }
1724 :
1725 : protected:
1726 23 : styled_string get_label_string (style_manager &sm) const
1727 : {
1728 23 : tree rep_tree = m_op.m_model.get_representative_tree (&m_sval);
1729 23 : if (rep_tree)
1730 : {
1731 23 : if (TREE_CODE (rep_tree) == SSA_NAME)
1732 13 : if (tree var = SSA_NAME_VAR (rep_tree))
1733 23 : rep_tree = var;
1734 23 : switch (TREE_CODE (rep_tree))
1735 : {
1736 : default:
1737 : break;
1738 9 : case INTEGER_CST:
1739 18 : return fmt_styled_string (sm, _("write of %<(%T) %E%>"),
1740 9 : TREE_TYPE (rep_tree),
1741 9 : rep_tree);
1742 :
1743 14 : case PARM_DECL:
1744 14 : case VAR_DECL:
1745 28 : return fmt_styled_string (sm, _("write from %qE (type: %qT)"),
1746 : rep_tree,
1747 14 : TREE_TYPE (rep_tree));
1748 : break;
1749 : }
1750 : }
1751 :
1752 0 : const symbolic_bit_range accessed_bits (m_op.get_actual_bits ());
1753 0 : return get_access_size_str (sm,
1754 : m_op,
1755 : accessed_bits,
1756 0 : m_sval.get_type ());
1757 : }
1758 :
1759 : const access_operation &m_op;
1760 : const svalue &m_sval;
1761 : symbolic_bit_range m_actual_bits;
1762 : };
1763 :
1764 : /* Subclass of svalue_spatial_item for initial_svalue of a string_region
1765 : i.e. for string literals.
1766 :
1767 : There are three cases:
1768 : (a) for long strings, show just the head and tail of the string,
1769 : with an ellipsis:
1770 : +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
1771 : |[0]|[1]|[2]|[3]|[4]|[5]| |[440]|[441]|[442]|[443]|[444]|[445]|
1772 : +---+---+---+---+---+---+ ... +-----+-----+-----+-----+-----+-----+
1773 : |‘L’|‘o’|‘r’|‘e’|‘m’|‘ ’| | ‘o’ | ‘r’ | ‘u’ | ‘m’ | ‘.’ | NUL |
1774 : +---+---+---+---+---+---+----------+-----+-----+-----+-----+-----+-----+
1775 : | string literal (type: ‘char[446]’) |
1776 : +----------------------------------------------------------------------+
1777 : (b) For sufficiently short strings, show the full string:
1778 : +----------+---------+---------+---------+---------+ +-----------------+
1779 : | [0] | [1] | [2] | [3] | [4] | | [5] |
1780 : +----------+---------+---------+---------+---------+ +-----------------+
1781 : | ‘h’ | ‘e’ | ‘l’ | ‘l’ | ‘o’ | | NUL |
1782 : +----------+---------+---------+---------+---------+-+-----------------+
1783 : | string literal (type: ‘char[6]’) |
1784 : +----------------------------------------------------------------------+
1785 : (c) for non-ASCII strings that are short enough to show the full string,
1786 : show how unicode code points of the bytes decoded as UTF-8:
1787 : +-----+-----+-----+----+----++----+----+----+----+----+----+----+------+
1788 : | [0] | [1] | [2] |[3] |[4] ||[5] |[6] |[7] |[8] |[9] |[10]|[11]| [12] |
1789 : +-----+-----+-----+----+----++----+----+----+----+----+----+----+------+
1790 : |0xe6 |0x96 |0x87 |0xe5|0xad||0x97|0xe5|0x8c|0x96|0xe3|0x81|0x91| 0x00 |
1791 : +-----+-----+-----+----+----++----+----+----+----+----+----+----+------+
1792 : | U+6587 | U+5b57 | U+5316 | U+3051 |U+0000|
1793 : +-----------------+---------------+--------------+--------------+------+
1794 : | string literal (type: ‘char[13]’) |
1795 : +----------------------------------------------------------------------+
1796 : and show the characters themselves if unicode is supported and they are not
1797 : control characters:
1798 : ┌─────┬─────┬─────┬────┬────┐┌────┬────┬────┬────┬────┬────┬────┬──────┐
1799 : │ [0] │ [1] │ [2] │[3] │[4] ││[5] │[6] │[7] │[8] │[9] │[10]│[11]│ [12] │
1800 : ├─────┼─────┼─────┼────┼────┤├────┼────┼────┼────┼────┼────┼────┼──────┤
1801 : │0xe6 │0x96 │0x87 │0xe5│0xad││0x97│0xe5│0x8c│0x96│0xe3│0x81│0x91│ 0x00 │
1802 : ├─────┴─────┴─────┼────┴────┴┴────┼────┴────┴────┼────┴────┴────┼──────┤
1803 : │ U+6587 │ U+5b57 │ U+5316 │ U+3051 │U+0000│
1804 : ├─────────────────┼───────────────┼──────────────┼──────────────┼──────┤
1805 : │ 文 │ 字 │ 化 │ け │ NUL │
1806 : ├─────────────────┴───────────────┴──────────────┴──────────────┴──────┤
1807 : │ string literal (type: ‘char[13]’) │
1808 : └──────────────────────────────────────────────────────────────────────┘
1809 : */
1810 :
1811 : class string_literal_spatial_item : public svalue_spatial_item
1812 : {
1813 : public:
1814 30 : string_literal_spatial_item (const svalue &sval,
1815 : symbolic_bit_range actual_bits,
1816 : const string_region &string_reg,
1817 : const theme &theme,
1818 : enum kind kind)
1819 : : svalue_spatial_item (sval, actual_bits, kind),
1820 30 : m_string_reg (string_reg),
1821 30 : m_theme (theme),
1822 60 : m_ellipsis_threshold (param_analyzer_text_art_string_ellipsis_threshold),
1823 30 : m_ellipsis_head_len (param_analyzer_text_art_string_ellipsis_head_len),
1824 30 : m_ellipsis_tail_len (param_analyzer_text_art_string_ellipsis_tail_len),
1825 30 : m_show_full_string (calc_show_full_string ()),
1826 60 : m_show_utf8 (m_show_full_string && !pure_ascii_p ())
1827 : {
1828 30 : }
1829 :
1830 30 : void add_boundaries (boundaries &out, logger *logger) const override
1831 : {
1832 30 : LOG_SCOPE (logger);
1833 30 : out.add (m_bit_range, m_kind == svalue_spatial_item::kind::WRITTEN
1834 30 : ? boundaries::kind::HARD
1835 : : boundaries::kind::SOFT);
1836 :
1837 30 : tree string_cst = get_string_cst ();
1838 : /* TREE_STRING_LENGTH is sizeof, not strlen. */
1839 30 : if (m_show_full_string)
1840 18 : out.add_all_bytes_in_range (m_bit_range);
1841 : else
1842 : {
1843 12 : concrete_bit_range conc_bit_range;
1844 12 : bool was_concrete
1845 12 : = concrete_from_symbolic (m_bit_range, &conc_bit_range);
1846 12 : gcc_assert (was_concrete);
1847 12 : concrete_byte_range bytes;
1848 12 : bool valid = maybe_bytes_from_bits (conc_bit_range, &bytes);
1849 12 : gcc_assert (valid);
1850 24 : concrete_byte_range head_of_string (bytes.get_start_offset (),
1851 24 : m_ellipsis_head_len);
1852 12 : out.add_all_bytes_in_range (head_of_string);
1853 12 : concrete_byte_range tail_of_string
1854 12 : ((bytes.get_start_offset ()
1855 24 : + concrete_byte_size (TREE_STRING_LENGTH (string_cst))
1856 36 : - m_ellipsis_tail_len),
1857 24 : m_ellipsis_tail_len);
1858 12 : out.add_all_bytes_in_range (tail_of_string);
1859 : /* Adding the above pair of ranges will also effectively add
1860 : the boundaries of the range of ellipsized chars, as they're
1861 : exactly in between head_of_string and tail_of_string. */
1862 48 : }
1863 30 : }
1864 :
1865 30 : table make_table (const bit_to_table_map &btm,
1866 : style_manager &sm) const override
1867 : {
1868 30 : table t (table::size_t (btm.get_num_columns (), 0));
1869 :
1870 30 : const int byte_idx_table_y = (m_kind == svalue_spatial_item::kind::WRITTEN
1871 30 : ? t.add_row ()
1872 : : -1);
1873 30 : const int byte_val_table_y = t.add_row ();
1874 :
1875 30 : concrete_bit_range conc_bits;
1876 30 : bool valid = concrete_from_symbolic<concrete_bit_offset> (m_bit_range,
1877 : &conc_bits);
1878 30 : gcc_assert (valid);
1879 30 : concrete_byte_range bytes;
1880 30 : valid = maybe_bytes_from_bits (conc_bits, &bytes);
1881 30 : gcc_assert (valid);
1882 30 : tree string_cst = get_string_cst ();
1883 30 : if (m_show_full_string)
1884 : {
1885 18 : for (concrete_byte_offset byte_idx_within_cluster
1886 18 : = bytes.get_start_offset ();
1887 155 : byte_idx_within_cluster < bytes.get_next_offset ();
1888 137 : byte_idx_within_cluster = byte_idx_within_cluster + 1_byte)
1889 137 : add_column_for_byte
1890 137 : (t, btm, sm, byte_idx_within_cluster,
1891 274 : byte_idx_within_cluster - bytes.get_start_offset (),
1892 18 : byte_idx_table_y, byte_val_table_y);
1893 :
1894 18 : if (m_show_utf8)
1895 : {
1896 6 : const bool show_unichars = m_theme.unicode_p ();
1897 6 : const int utf8_code_point_table_y = t.add_row ();
1898 6 : int utf8_character_table_y;
1899 6 : if (show_unichars)
1900 5 : utf8_character_table_y = t.add_row ();
1901 :
1902 : /* We don't actually want the display widths here, but
1903 : it's an easy way to decode UTF-8. */
1904 6 : cpp_char_column_policy policy (8, cpp_wcwidth);
1905 6 : cpp_display_width_computation dw (TREE_STRING_POINTER (string_cst),
1906 6 : TREE_STRING_LENGTH (string_cst),
1907 6 : policy);
1908 47 : while (!dw.done ())
1909 : {
1910 35 : cpp_decoded_char decoded_char;
1911 35 : dw.process_next_codepoint (&decoded_char);
1912 :
1913 35 : if (!decoded_char.m_valid_ch)
1914 0 : continue;
1915 35 : concrete_byte_offset start_byte_idx
1916 35 : (decoded_char.m_start_byte - TREE_STRING_POINTER (string_cst));
1917 35 : concrete_byte_size size_in_bytes
1918 35 : (decoded_char.m_next_byte - decoded_char.m_start_byte);
1919 35 : concrete_byte_range cluster_bytes_for_codepoint
1920 35 : (concrete_byte_offset (start_byte_idx)
1921 105 : + bytes.get_start_offset (),
1922 70 : size_in_bytes);
1923 :
1924 35 : const table::rect_t code_point_table_rect
1925 35 : = btm.get_table_rect (cluster_bytes_for_codepoint,
1926 : utf8_code_point_table_y, 1);
1927 35 : char buf[100];
1928 35 : sprintf (buf, "U+%04x", decoded_char.m_ch);
1929 35 : t.set_cell_span (code_point_table_rect,
1930 70 : styled_string (sm, buf));
1931 :
1932 35 : if (show_unichars)
1933 : {
1934 30 : const table::rect_t character_table_rect
1935 30 : = btm.get_table_rect (cluster_bytes_for_codepoint,
1936 : utf8_character_table_y, 1);
1937 30 : if (cpp_is_printable_char (decoded_char.m_ch))
1938 23 : t.set_cell_span (character_table_rect,
1939 46 : styled_string (decoded_char.m_ch));
1940 7 : else if (decoded_char.m_ch == 0)
1941 5 : t.set_cell_span (character_table_rect,
1942 10 : styled_string (sm, "NUL"));
1943 : else
1944 2 : t.set_cell_span (character_table_rect,
1945 4 : styled_string (sm, ""));
1946 : }
1947 35 : }
1948 : }
1949 : }
1950 : else
1951 : {
1952 : /* Head of string. */
1953 12 : for (concrete_byte_offset byte_idx = 0_bytes;
1954 84 : byte_idx < m_ellipsis_head_len; ++byte_idx)
1955 216 : add_column_for_byte (t, btm, sm,
1956 144 : byte_idx + bytes.get_start_offset (),
1957 : byte_idx,
1958 12 : byte_idx_table_y, byte_val_table_y);
1959 :
1960 : /* Ellipsis. */
1961 12 : concrete_byte_range ellipsis_bytes
1962 24 : (m_ellipsis_head_len + bytes.get_start_offset (),
1963 24 : concrete_byte_size (TREE_STRING_LENGTH (string_cst))
1964 48 : - (m_ellipsis_head_len + m_ellipsis_tail_len));
1965 12 : const table::rect_t table_rect
1966 : = ((byte_idx_table_y != -1)
1967 12 : ? btm.get_table_rect (ellipsis_bytes,
1968 : byte_idx_table_y, 2)
1969 6 : : btm.get_table_rect (ellipsis_bytes,
1970 : byte_val_table_y, 1));
1971 12 : t.set_cell_span(table_rect, styled_string (sm, "..."));
1972 :
1973 : /* Tail of string. */
1974 84 : for (concrete_byte_offset byte_idx
1975 24 : = (concrete_byte_size (TREE_STRING_LENGTH (string_cst))
1976 24 : - m_ellipsis_tail_len);
1977 84 : byte_idx < concrete_byte_size (TREE_STRING_LENGTH (string_cst));
1978 72 : ++byte_idx)
1979 216 : add_column_for_byte (t, btm, sm,
1980 144 : byte_idx + bytes.get_start_offset (),
1981 : byte_idx,
1982 12 : byte_idx_table_y, byte_val_table_y);
1983 12 : }
1984 :
1985 30 : if (m_kind == svalue_spatial_item::kind::WRITTEN)
1986 : {
1987 17 : const int summary_table_y = t.add_row ();
1988 17 : t.set_cell_span (btm.get_table_rect (bytes,
1989 : summary_table_y, 1),
1990 34 : fmt_styled_string (sm,
1991 17 : _("string literal (type: %qT)"),
1992 17 : TREE_TYPE (string_cst)));
1993 : }
1994 :
1995 30 : return t;
1996 30 : }
1997 :
1998 60 : tree get_string_cst () const { return m_string_reg.get_string_cst (); }
1999 :
2000 : private:
2001 30 : bool calc_show_full_string () const
2002 : {
2003 30 : tree string_cst = get_string_cst ();
2004 30 : concrete_byte_size string_len (TREE_STRING_LENGTH (string_cst));
2005 30 : if (string_len < m_ellipsis_threshold)
2006 : return true;
2007 13 : if (string_len < (m_ellipsis_head_len + m_ellipsis_tail_len))
2008 1 : return true;
2009 : return false;
2010 30 : }
2011 :
2012 18 : bool pure_ascii_p () const
2013 : {
2014 18 : tree string_cst = get_string_cst ();
2015 104 : for (unsigned byte_idx = 0;
2016 104 : byte_idx < (unsigned) TREE_STRING_LENGTH (string_cst);
2017 : byte_idx++)
2018 : {
2019 92 : unsigned char ch = TREE_STRING_POINTER (string_cst)[byte_idx];
2020 92 : if (ch >= 0x80)
2021 : return false;
2022 : }
2023 : return true;
2024 : }
2025 :
2026 281 : void add_column_for_byte (table &t, const bit_to_table_map &btm,
2027 : style_manager &sm,
2028 : const concrete_byte_offset byte_idx_within_cluster,
2029 : const concrete_byte_offset byte_idx_within_string,
2030 : const int byte_idx_table_y,
2031 : const int byte_val_table_y) const
2032 : {
2033 281 : tree string_cst = get_string_cst ();
2034 281 : gcc_assert (byte_idx_within_string >= 0_bytes);
2035 281 : gcc_assert (byte_idx_within_string
2036 : < concrete_byte_size (TREE_STRING_LENGTH (string_cst)));
2037 :
2038 562 : const concrete_byte_range bytes (byte_idx_within_cluster, 1_byte);
2039 281 : if (byte_idx_table_y != -1)
2040 : {
2041 168 : const table::rect_t idx_table_rect
2042 168 : = btm.get_table_rect (bytes, byte_idx_table_y, 1);
2043 168 : pp_element_integer e_byte_idx_within_string
2044 168 : (byte_idx_within_string.get_integer ());
2045 168 : t.set_cell_span (idx_table_rect,
2046 336 : fmt_styled_string (sm, "[%e]",
2047 : &e_byte_idx_within_string));
2048 168 : }
2049 :
2050 281 : char byte_val
2051 281 : = TREE_STRING_POINTER (string_cst)[byte_idx_within_string.as_unsigned_long ()];
2052 281 : const table::rect_t val_table_rect
2053 281 : = btm.get_table_rect (bytes, byte_val_table_y, 1);
2054 281 : table_cell_content content (make_cell_content_for_byte (sm, byte_val));
2055 281 : t.set_cell_span (val_table_rect, std::move (content));
2056 281 : }
2057 :
2058 281 : table_cell_content make_cell_content_for_byte (style_manager &sm,
2059 : unsigned char byte_val) const
2060 : {
2061 281 : if (!m_show_utf8)
2062 : {
2063 218 : if (byte_val == '\0')
2064 24 : return styled_string (sm, "NUL");
2065 194 : else if (byte_val < 0x80)
2066 194 : if (ISPRINT (byte_val))
2067 190 : return fmt_styled_string (sm, "%qc", byte_val);
2068 : }
2069 67 : char buf[100];
2070 67 : sprintf (buf, "0x%02x", byte_val);
2071 67 : return styled_string (sm, buf);
2072 : }
2073 :
2074 : const string_region &m_string_reg;
2075 : const theme &m_theme;
2076 : const concrete_byte_size m_ellipsis_threshold;
2077 : const concrete_byte_size m_ellipsis_head_len;
2078 : const concrete_byte_size m_ellipsis_tail_len;
2079 : const bool m_show_full_string;
2080 : const bool m_show_utf8;
2081 : };
2082 :
2083 : static std::unique_ptr<spatial_item>
2084 40 : make_written_svalue_spatial_item (const access_operation &op,
2085 : const svalue &sval,
2086 : symbolic_bit_range actual_bits,
2087 : const theme &theme)
2088 : {
2089 40 : if (const initial_svalue *initial_sval = sval.dyn_cast_initial_svalue ())
2090 30 : if (const string_region *string_reg
2091 30 : = initial_sval->get_region ()->dyn_cast_string_region ())
2092 17 : return std::make_unique <string_literal_spatial_item>
2093 17 : (sval, actual_bits,
2094 : *string_reg, theme,
2095 17 : svalue_spatial_item::kind::WRITTEN);
2096 23 : return std::make_unique <written_svalue_spatial_item> (op, sval, actual_bits);
2097 : }
2098 :
2099 : static std::unique_ptr<spatial_item>
2100 79 : make_existing_svalue_spatial_item (const svalue *sval,
2101 : const symbolic_bit_range &bit_range,
2102 : const theme &theme)
2103 : {
2104 79 : if (!sval)
2105 0 : return nullptr;
2106 :
2107 79 : switch (sval->get_kind ())
2108 : {
2109 0 : default:
2110 0 : return nullptr;
2111 :
2112 26 : case SK_INITIAL:
2113 26 : {
2114 26 : const initial_svalue *initial_sval = (const initial_svalue *)sval;
2115 26 : if (const string_region *string_reg
2116 26 : = initial_sval->get_region ()->dyn_cast_string_region ())
2117 13 : return std::make_unique <string_literal_spatial_item>
2118 13 : (*sval, bit_range,
2119 : *string_reg, theme,
2120 13 : svalue_spatial_item::kind::EXISTING);
2121 13 : return nullptr;
2122 : }
2123 :
2124 53 : case SK_BIT_VECTOR:
2125 53 : return std::make_unique<svalue_from_bit_vector_spatial_item>
2126 53 : (*((const svalue_from_bit_vector *)sval),
2127 : bit_range,
2128 106 : svalue_spatial_item::kind::EXISTING,
2129 53 : theme);
2130 : }
2131 : }
2132 :
2133 : /* Widget subclass implementing access diagrams. */
2134 :
2135 : class access_diagram_impl : public vbox_widget
2136 : {
2137 : public:
2138 68 : access_diagram_impl (const access_operation &op,
2139 : diagnostics::paths::event_id_t region_creation_event_id,
2140 : style_manager &sm,
2141 : const theme &theme,
2142 : logger *logger)
2143 68 : : m_node_mgr (op.m_model.get_manager ()->get_node_manager ()),
2144 68 : m_op (op),
2145 68 : m_region_creation_event_id (region_creation_event_id),
2146 68 : m_sm (sm),
2147 68 : m_theme (theme),
2148 68 : m_logger (logger),
2149 68 : m_invalid (false),
2150 68 : m_valid_region_spatial_item (op, region_creation_event_id, theme),
2151 68 : m_accessed_region_spatial_item (op),
2152 68 : m_btm (m_node_mgr),
2153 68 : m_calc_req_size_called (false)
2154 : {
2155 68 : LOG_SCOPE (logger);
2156 :
2157 68 : if (logger)
2158 : {
2159 0 : symbolic_bit_range invalid_before_bits;
2160 0 : if (op.maybe_get_invalid_before_bits (&invalid_before_bits))
2161 0 : invalid_before_bits.log ("invalid before range", *logger);
2162 0 : symbolic_bit_range invalid_after_bits;
2163 0 : if (op.maybe_get_invalid_after_bits (&invalid_after_bits))
2164 0 : invalid_after_bits.log ("invalid after range", *logger);
2165 :
2166 0 : if (op.m_sval_hint)
2167 : {
2168 0 : logger->start_log_line ();
2169 0 : logger->log_partial ("sval_hint: ");
2170 0 : op.m_sval_hint->dump_to_pp (logger->get_printer (), true);
2171 0 : logger->end_log_line ();
2172 : }
2173 : }
2174 :
2175 : /* Register painting styles. */
2176 68 : {
2177 68 : style valid_style (get_style_from_color_cap_name ("valid"));
2178 68 : m_valid_style_id = m_sm.get_or_create_id (valid_style);
2179 :
2180 68 : style invalid_style (get_style_from_color_cap_name ("invalid"));
2181 68 : m_invalid_style_id = m_sm.get_or_create_id (invalid_style);
2182 68 : }
2183 :
2184 68 : if (op.m_sval_hint)
2185 : {
2186 40 : symbolic_bit_range actual_bits = m_op.get_actual_bits ();
2187 40 : m_written_svalue_spatial_item
2188 40 : = make_written_svalue_spatial_item (m_op,
2189 40 : *op.m_sval_hint,
2190 : actual_bits,
2191 40 : m_theme);
2192 : }
2193 :
2194 : /* Two passes:
2195 : First, figure out all of the boundaries of interest.
2196 : Then use that to build child widgets showing the regions of interest,
2197 : with a common tabular layout. */
2198 :
2199 68 : m_boundaries = find_boundaries ();
2200 68 : if (logger)
2201 0 : m_boundaries->log (*logger);
2202 :
2203 : /* Populate m_table_x_for_bit and m_bit_for_table_x.
2204 : Each table column represents the range [offset, next_offset).
2205 : We don't create a column in the table for the final offset, but we
2206 : do populate it, so that looking at the table_x of one beyond the
2207 : final table column gives us the upper bound offset. */
2208 68 : m_btm.populate (*m_boundaries, logger);
2209 :
2210 : /* Gracefully reject cases where the boundary sorting has gone wrong
2211 : (due to awkward combinations of symbolic values). */
2212 68 : {
2213 68 : table::range_t actual_bits_x_range
2214 68 : = m_btm.get_table_x_for_range (m_op.get_actual_bits ());
2215 68 : if (actual_bits_x_range.get_size () <= 0)
2216 : {
2217 0 : if (logger)
2218 0 : logger->log ("giving up: bad table columns for actual_bits");
2219 0 : m_invalid = true;
2220 0 : return;
2221 : }
2222 68 : table::range_t valid_bits_x_range
2223 68 : = m_btm.get_table_x_for_range (m_op.get_valid_bits ());
2224 68 : if (valid_bits_x_range.get_size () <= 0)
2225 : {
2226 0 : if (logger)
2227 0 : logger->log ("giving up: bad table columns for valid_bits");
2228 0 : m_invalid = true;
2229 0 : return;
2230 : }
2231 : }
2232 :
2233 68 : m_col_widths
2234 68 : = std::make_unique <table_dimension_sizes> (m_btm.get_num_columns ());
2235 :
2236 : /* Now create child widgets. */
2237 :
2238 68 : if (flag_analyzer_debug_text_art)
2239 : {
2240 1 : table t_headings (make_headings_table ());
2241 2 : add_aligned_child_table (std::move (t_headings));
2242 1 : }
2243 :
2244 68 : if (m_written_svalue_spatial_item)
2245 : {
2246 40 : table t_sval (m_written_svalue_spatial_item->make_table (m_btm, m_sm));
2247 80 : add_aligned_child_table (std::move (t_sval));
2248 40 : }
2249 : else
2250 : {
2251 28 : table t_accessed
2252 28 : (m_accessed_region_spatial_item.make_table (m_btm, m_sm));
2253 56 : add_aligned_child_table (std::move (t_accessed));
2254 28 : }
2255 :
2256 68 : add_direction_widget ();
2257 :
2258 68 : table t_valid (m_valid_region_spatial_item.make_table (m_btm, m_sm));
2259 68 : add_invalid_accesses_to_region_table (t_valid);
2260 68 : add_aligned_child_table (std::move (t_valid));
2261 :
2262 68 : add_valid_vs_invalid_ruler ();
2263 68 : }
2264 :
2265 0 : const char *get_desc () const override
2266 : {
2267 0 : return "access_diagram_impl";
2268 : }
2269 :
2270 68 : canvas::size_t calc_req_size () final override
2271 : {
2272 68 : if (m_invalid)
2273 0 : return canvas::size_t (0, 0);
2274 :
2275 : /* Now compute the size requirements for the tables. */
2276 205 : for (auto iter : m_aligned_table_widgets)
2277 137 : iter->get_cell_sizes ().pass_1 (iter->get_table ());
2278 205 : for (auto iter : m_aligned_table_widgets)
2279 137 : iter->get_cell_sizes ().pass_2 (iter->get_table ());
2280 :
2281 68 : adjust_to_scale();
2282 :
2283 : /* ...and relayout the tables. */
2284 205 : for (auto iter : m_aligned_table_widgets)
2285 137 : iter->recalc_coords ();
2286 :
2287 : /* Populate the canvas_x per table_x. */
2288 68 : m_col_start_x.clear ();
2289 68 : int iter_canvas_x = 0;
2290 68 : gcc_assert (m_col_widths);
2291 612 : for (auto w : m_col_widths->m_requirements)
2292 : {
2293 544 : m_col_start_x.push_back (iter_canvas_x);
2294 544 : iter_canvas_x += w + 1;
2295 : }
2296 68 : m_col_start_x.push_back (iter_canvas_x);
2297 :
2298 68 : m_calc_req_size_called = true;
2299 :
2300 68 : return vbox_widget::calc_req_size ();
2301 : }
2302 :
2303 1160 : int get_canvas_x_for_table_x (int table_x) const
2304 : {
2305 1160 : gcc_assert (m_calc_req_size_called);
2306 1160 : return m_col_start_x[table_x];
2307 : }
2308 :
2309 580 : canvas::range_t get_canvas_x_range (const table::range_t &table_x_range) const
2310 : {
2311 580 : gcc_assert (m_calc_req_size_called);
2312 1160 : return canvas::range_t (get_canvas_x_for_table_x (table_x_range.start),
2313 580 : get_canvas_x_for_table_x (table_x_range.next));
2314 : }
2315 :
2316 416 : const access_operation &get_op () const { return m_op; }
2317 :
2318 280 : style::id_t get_style_id_for_validity (bool is_valid) const
2319 : {
2320 280 : return is_valid ? m_valid_style_id : m_invalid_style_id;
2321 : }
2322 :
2323 280 : const theme &get_theme () const { return m_theme; }
2324 :
2325 : private:
2326 : /* Figure out all of the boundaries of interest when visualizing the op. */
2327 : std::unique_ptr<boundaries>
2328 68 : find_boundaries () const
2329 : {
2330 68 : auto result
2331 68 : = std::make_unique<boundaries> (m_op.get_manager ()->get_node_manager (),
2332 68 : m_op.m_attempted_range.get_base_region (),
2333 68 : m_logger);
2334 68 : m_valid_region_spatial_item.add_boundaries (*result, m_logger);
2335 68 : m_accessed_region_spatial_item.add_boundaries (*result, m_logger);
2336 68 : if (m_written_svalue_spatial_item)
2337 40 : m_written_svalue_spatial_item->add_boundaries (*result, m_logger);
2338 68 : return result;
2339 : }
2340 :
2341 137 : void add_aligned_child_table (table t)
2342 : {
2343 137 : auto w = std::make_unique<x_aligned_table_widget> (std::move (t),
2344 137 : m_theme, *m_col_widths);
2345 137 : m_aligned_table_widgets.push_back (w.get ());
2346 137 : add_child (std::move (w));
2347 137 : }
2348 :
2349 : /* Create a table showing headings for use by -fanalyzer-debug-text-art, for
2350 : example:
2351 : +---------+-----------+-----------+---+--------------------------------+
2352 : | tc0 | tc1 | tc2 |tc3| tc4 |
2353 : +---------+-----------+-----------+---+--------------------------------+
2354 : |bytes 0-3|bytes 4-35 |bytes 36-39| | bytes 40-43 |
2355 : +---------+-----------+-----------+ +--------------------------------+
2356 : which has:
2357 : - a row showing the table column numbers, labelled "tc0", "tc1", etc
2358 : - a row showing the memory range of each table column that has one. */
2359 :
2360 1 : table make_headings_table () const
2361 : {
2362 1 : table t (table::size_t (m_btm.get_num_columns (), 2));
2363 :
2364 6 : for (int table_x = 0; table_x < t.get_size ().w; table_x++)
2365 : {
2366 5 : const int table_y = 0;
2367 5 : t.set_cell (table::coord_t (table_x, table_y),
2368 10 : fmt_styled_string (m_sm, "tc%i", table_x));
2369 : }
2370 6 : for (int table_x = 0; table_x < t.get_size ().w; table_x++)
2371 : {
2372 5 : const int table_y = 1;
2373 5 : symbolic_bit_range range_for_column;
2374 5 : if (m_btm.maybe_get_symbolic_bit_range_for_table_x (table_x,
2375 : &range_for_column))
2376 : {
2377 4 : pretty_printer pp;
2378 4 : pp_format_decoder (&pp) = default_tree_printer;
2379 4 : range_for_column.dump_inline_to_pp (&pp);
2380 4 : t.set_cell (table::coord_t (table_x, table_y),
2381 8 : styled_string (m_sm, pp_formatted_text (&pp)));
2382 4 : }
2383 : }
2384 :
2385 1 : return t;
2386 : }
2387 :
2388 68 : void add_direction_widget ()
2389 : {
2390 68 : add_child (std::make_unique<direction_widget> (*this, m_btm));
2391 68 : }
2392 :
2393 68 : void add_invalid_accesses_to_region_table (table &t_region)
2394 : {
2395 68 : gcc_assert (t_region.get_size ().w == (int)m_btm.get_num_columns ());
2396 :
2397 68 : const int table_y = 0;
2398 68 : const int table_h = t_region.get_size ().h;
2399 :
2400 68 : symbolic_bit_range invalid_before_bits;
2401 68 : if (m_op.maybe_get_invalid_before_bits (&invalid_before_bits))
2402 : {
2403 15 : t_region.set_cell_span (m_btm.get_table_rect (invalid_before_bits,
2404 : table_y, table_h),
2405 30 : styled_string (m_sm,
2406 15 : _("before valid range")));
2407 : }
2408 68 : symbolic_bit_range invalid_after_bits;
2409 68 : if (m_op.maybe_get_invalid_after_bits (&invalid_after_bits))
2410 : {
2411 57 : t_region.set_cell_span (m_btm.get_table_rect (invalid_after_bits,
2412 : table_y, table_h),
2413 114 : styled_string (m_sm,
2414 57 : _("after valid range")));
2415 : }
2416 68 : }
2417 :
2418 72 : void maybe_add_gap (x_aligned_x_ruler_widget *w,
2419 : const symbolic_bit_range &lower,
2420 : const symbolic_bit_range &upper) const
2421 : {
2422 72 : LOG_SCOPE (m_logger);
2423 72 : if (m_logger)
2424 : {
2425 0 : lower.log ("lower", *m_logger);
2426 0 : upper.log ("upper", *m_logger);
2427 : }
2428 72 : auto &num_bits_gap = (upper.get_start_offset ()
2429 72 : - lower.get_next_offset ());
2430 72 : if (m_logger)
2431 : {
2432 0 : symbolic::pp_element_for_node e (num_bits_gap);
2433 0 : m_logger->log ("num_bits_gap: %e", &e);
2434 0 : }
2435 :
2436 72 : auto &bit_mgr = m_node_mgr.get_scalars ().get_bits ();
2437 72 : auto &zero = bit_mgr.get_concrete (0_bits);
2438 72 : if (num_bits_gap <= zero)
2439 : {
2440 62 : if (m_logger)
2441 0 : m_logger->log ("rejecting as not > 0");
2442 62 : return;
2443 : }
2444 :
2445 10 : bit_size_expr num_bits (num_bits_gap);
2446 10 : if (auto p = num_bits.maybe_get_formatted_str (m_sm, m_op.m_model,
2447 10 : _("%e bit"),
2448 10 : _("%e bits"),
2449 10 : _("%e byte"),
2450 10 : _("%e bytes"),
2451 10 : _("%qs bits"),
2452 10 : _("%qs bytes")))
2453 : {
2454 10 : styled_string label = std::move (*p.get ());
2455 10 : w->add_range
2456 20 : (m_btm.get_table_x_for_range
2457 20 : (folded_symbolic_bit_range (lower.get_next_offset (),
2458 : num_bits_gap)),
2459 : std::move (label),
2460 : style::id_plain);
2461 10 : }
2462 72 : }
2463 :
2464 : styled_string
2465 72 : make_warning_string (styled_string &&text)
2466 : {
2467 72 : styled_string result;
2468 72 : if (!m_theme.emojis_p ())
2469 71 : return std::move (text);
2470 :
2471 1 : result.append (styled_string (0x26A0, /* U+26A0 WARNING SIGN. */
2472 1 : true));
2473 : /* U+26A0 WARNING SIGN has East_Asian_Width == Neutral, but in its
2474 : emoji variant is printed (by vte at least) with a 2nd half
2475 : overlapping the next char. Hence we add two spaces here: a space
2476 : to be covered by this overlap, plus another space of padding. */
2477 1 : result.append (styled_string (m_sm, " "));
2478 1 : result.append (text);
2479 1 : return result;
2480 72 : }
2481 :
2482 : /* Add a ruler child widet showing valid, invalid, and gaps. */
2483 68 : void add_valid_vs_invalid_ruler ()
2484 : {
2485 68 : LOG_SCOPE (m_logger);
2486 :
2487 68 : auto w = std::make_unique<x_aligned_x_ruler_widget> (*this, m_theme);
2488 :
2489 68 : symbolic_bit_range invalid_before_bits;
2490 68 : bool got_invalid_before_bits
2491 68 : = m_op.maybe_get_invalid_before_bits (&invalid_before_bits);
2492 68 : if (got_invalid_before_bits)
2493 : {
2494 15 : if (m_logger)
2495 0 : invalid_before_bits.log ("invalid_before_bits", *m_logger);
2496 :
2497 15 : bit_size_expr num_before_bits (invalid_before_bits.get_size ());
2498 15 : std::unique_ptr<styled_string> label;
2499 15 : if (m_op.m_dir == access_direction::read)
2500 8 : label = num_before_bits.maybe_get_formatted_str
2501 16 : (m_sm, m_op.m_model,
2502 8 : _("under-read of %e bit"),
2503 8 : _("under-read of %e bits"),
2504 8 : _("under-read of %e byte"),
2505 8 : _("under-read of %e bytes"),
2506 8 : _("under-read of %qs bits"),
2507 16 : _("under-read of %qs bytes"));
2508 : else
2509 7 : label = num_before_bits.maybe_get_formatted_str
2510 14 : (m_sm, m_op.m_model,
2511 7 : _("underwrite of %e bit"),
2512 7 : _("underwrite of %e bits"),
2513 7 : _("underwrite of %e byte"),
2514 7 : _("underwrite of %e bytes"),
2515 7 : _("underwrite of %qs bits"),
2516 14 : _("underwrite of %qs bytes"));
2517 15 : if (label)
2518 15 : w->add_range (m_btm.get_table_x_for_range (invalid_before_bits),
2519 30 : make_warning_string (std::move (*label)),
2520 : m_invalid_style_id);
2521 15 : }
2522 : else
2523 : {
2524 53 : if (m_logger)
2525 0 : m_logger->log ("no invalid_before_bits");
2526 : }
2527 :
2528 : /* It would be nice to be able to use std::optional<symbolic_bit_range> here,
2529 : but std::optional is C++17. */
2530 68 : bool got_valid_bits = false;
2531 68 : symbolic_bit_range valid_bits (m_op.get_valid_bits ());
2532 68 : bit_size_expr num_valid_bits (valid_bits.get_size ());
2533 :
2534 68 : if (m_logger)
2535 0 : valid_bits.log ("valid_bits", *m_logger);
2536 :
2537 68 : got_valid_bits = true;
2538 68 : if (got_invalid_before_bits && got_valid_bits)
2539 15 : maybe_add_gap (w.get (), invalid_before_bits, valid_bits);
2540 :
2541 68 : std::unique_ptr<styled_string> label;
2542 68 : if (m_op.m_dir == access_direction::read)
2543 26 : label = num_valid_bits.maybe_get_formatted_str (m_sm,
2544 13 : m_op.m_model,
2545 13 : _("size: %e bit"),
2546 13 : _("size: %e bits"),
2547 13 : _("size: %e byte"),
2548 13 : _("size: %e bytes"),
2549 13 : _("size: %qs bits"),
2550 26 : _("size: %qs bytes"));
2551 : else
2552 55 : label
2553 110 : = num_valid_bits.maybe_get_formatted_str (m_sm,
2554 55 : m_op.m_model,
2555 55 : _("capacity: %e bit"),
2556 55 : _("capacity: %e bits"),
2557 55 : _("capacity: %e byte"),
2558 55 : _("capacity: %e bytes"),
2559 55 : _("capacity: %qs bits"),
2560 110 : _("capacity: %qs bytes"));
2561 68 : if (label)
2562 68 : w->add_range (m_btm.get_table_x_for_range (m_op.get_valid_bits ()),
2563 68 : std::move (*label),
2564 : m_valid_style_id);
2565 :
2566 68 : symbolic_bit_range invalid_after_bits;
2567 68 : bool got_invalid_after_bits
2568 68 : = m_op.maybe_get_invalid_after_bits (&invalid_after_bits);
2569 68 : if (got_invalid_after_bits)
2570 : {
2571 57 : if (got_valid_bits)
2572 57 : maybe_add_gap (w.get (), valid_bits, invalid_after_bits);
2573 :
2574 57 : if (m_logger)
2575 0 : invalid_after_bits.log ("invalid_after_bits", *m_logger);
2576 :
2577 57 : bit_size_expr num_after_bits (invalid_after_bits.get_size ());
2578 57 : std::unique_ptr<styled_string> label;
2579 57 : if (m_op.m_dir == access_direction::read)
2580 7 : label = num_after_bits.maybe_get_formatted_str
2581 14 : (m_sm, m_op.m_model,
2582 7 : _("over-read of %e bit"),
2583 7 : _("over-read of %e bits"),
2584 7 : _("over-read of %e byte"),
2585 7 : _("over-read of %e bytes"),
2586 7 : _("over-read of %qs bits"),
2587 14 : _("over-read of %qs bytes"));
2588 : else
2589 50 : label = num_after_bits.maybe_get_formatted_str
2590 100 : (m_sm, m_op.m_model,
2591 50 : _("overflow of %e bit"),
2592 50 : _("overflow of %e bits"),
2593 50 : _("overflow of %e byte"),
2594 50 : _("overflow of %e bytes"),
2595 50 : _("overflow of %qs bits"),
2596 100 : _("overflow of %qs bytes"));
2597 57 : if (label)
2598 57 : w->add_range (m_btm.get_table_x_for_range (invalid_after_bits),
2599 114 : make_warning_string (std::move (*label)),
2600 : m_invalid_style_id);
2601 57 : }
2602 : else
2603 : {
2604 11 : if (m_logger)
2605 0 : m_logger->log ("no invalid_after_bits");
2606 : }
2607 :
2608 68 : add_child (std::move (w));
2609 68 : }
2610 :
2611 : /* Subroutine of calc_req_size.
2612 : Try to allocate surplus canvas width to table columns to make the
2613 : per table-column canvas widths closer to being to scale.
2614 : See e.g.:
2615 : https://en.wikipedia.org/wiki/Fair_item_allocation
2616 : https://en.wikipedia.org/wiki/Mathematics_of_apportionment
2617 : */
2618 68 : void adjust_to_scale ()
2619 : {
2620 68 : LOG_SCOPE (m_logger);
2621 68 : const unsigned num_columns = m_btm.get_num_columns ();
2622 68 : std::vector<bit_offset_t> bit_sizes (num_columns);
2623 612 : for (unsigned table_x = 0; table_x < num_columns; table_x++)
2624 : {
2625 544 : symbolic_bit_range range_for_column;
2626 544 : if (m_btm.maybe_get_symbolic_bit_range_for_table_x (table_x,
2627 : &range_for_column))
2628 : {
2629 447 : bit_size_t size_in_bits;
2630 447 : concrete_bit_size conc_bit_size;
2631 447 : if (concrete_from_symbolic (range_for_column.get_size (), &conc_bit_size))
2632 416 : size_in_bits = convert_to_bit_size_t (conc_bit_size);
2633 : else
2634 31 : size_in_bits = BITS_PER_UNIT; // arbitrary non-zero value
2635 447 : gcc_assert (size_in_bits > 0);
2636 447 : bit_sizes[table_x] = size_in_bits;
2637 447 : }
2638 : else
2639 97 : bit_sizes[table_x] = 0;
2640 : }
2641 :
2642 829 : while (adjust_to_scale_once (bit_sizes))
2643 : {
2644 : }
2645 68 : }
2646 829 : bool adjust_to_scale_once (const std::vector<bit_offset_t> &bit_sizes)
2647 : {
2648 829 : LOG_SCOPE (m_logger);
2649 :
2650 829 : const unsigned num_columns = m_btm.get_num_columns ();
2651 :
2652 : /* Find the total canvas width currently required.
2653 : Require one extra canvas column for the right-hand border
2654 : of the table. */
2655 829 : int total_width = 1;
2656 5168 : for (unsigned table_x = 0; table_x < num_columns; table_x++)
2657 : {
2658 4339 : int canvas_w = m_col_widths->m_requirements[table_x];
2659 4339 : gcc_assert (canvas_w >= 0);
2660 4339 : total_width += canvas_w + 1;
2661 : }
2662 :
2663 829 : const int max_width = param_analyzer_text_art_ideal_canvas_width;
2664 829 : if (total_width >= max_width)
2665 : {
2666 68 : if (m_logger)
2667 0 : m_logger->log ("bailing out: total_width=%i ,>= max_width (%i)\n",
2668 : total_width, max_width);
2669 : return false;
2670 : }
2671 :
2672 761 : const int fixed_point = 1024;
2673 761 : std::vector<bit_offset_t> canvas_w_per_bit (num_columns);
2674 4556 : for (unsigned table_x = 0; table_x < num_columns; table_x++)
2675 : {
2676 3795 : bit_offset_t bit_size = bit_sizes[table_x];
2677 3795 : if (bit_size > 0)
2678 5514 : canvas_w_per_bit[table_x]
2679 2757 : = (m_col_widths->m_requirements[table_x] * fixed_point) / bit_size;
2680 : else
2681 1038 : canvas_w_per_bit[table_x] = INT_MAX;
2682 : }
2683 :
2684 : /* Find the min canvas per bit, and give an extra canvas column to
2685 : the table column that has least. */
2686 761 : size_t min_idx = std::distance (canvas_w_per_bit.begin (),
2687 : std::min_element (canvas_w_per_bit.begin (),
2688 761 : canvas_w_per_bit.end ()));
2689 761 : m_col_widths->m_requirements[min_idx] += 1;
2690 761 : if (m_logger)
2691 0 : m_logger->log ("adding 1 canvas_w to column %i\n", (int)min_idx);
2692 :
2693 761 : return true; // keep going
2694 829 : }
2695 :
2696 : symbolic::node_manager &m_node_mgr;
2697 : const access_operation &m_op;
2698 : diagnostics::paths::event_id_t m_region_creation_event_id;
2699 : style_manager &m_sm;
2700 : const theme &m_theme;
2701 : logger *m_logger;
2702 : /* In lieu of being able to throw exceptions, a flag to mark this object
2703 : as "invalid". */
2704 : bool m_invalid;
2705 :
2706 : style::id_t m_valid_style_id;
2707 : style::id_t m_invalid_style_id;
2708 :
2709 : valid_region_spatial_item m_valid_region_spatial_item;
2710 : accessed_region_spatial_item m_accessed_region_spatial_item;
2711 : std::unique_ptr<spatial_item> m_written_svalue_spatial_item;
2712 :
2713 : std::unique_ptr<boundaries> m_boundaries;
2714 :
2715 : bit_to_table_map m_btm;
2716 :
2717 : bool m_calc_req_size_called;
2718 :
2719 : /* Column widths shared by all x_aligned_table_widget,
2720 : created once we know how many columns we need. */
2721 : std::unique_ptr<table_dimension_sizes> m_col_widths;
2722 :
2723 : /* All of the child x_aligned_table_widget that share
2724 : column widths. */
2725 : std::vector<x_aligned_table_widget *> m_aligned_table_widgets;
2726 :
2727 : /* Mapping from table_x to canvas_x. */
2728 : std::vector<int> m_col_start_x;
2729 : };
2730 :
2731 : x_ruler
2732 136 : x_aligned_x_ruler_widget::make_x_ruler () const
2733 : {
2734 136 : x_ruler r (x_ruler::label_dir::BELOW);
2735 436 : for (auto& iter : m_labels)
2736 : {
2737 300 : canvas::range_t canvas_x_range
2738 300 : = m_dia_impl.get_canvas_x_range (iter.m_table_x_range);
2739 : /* Include the end-point. */
2740 300 : canvas_x_range.next++;
2741 300 : r.add_label (canvas_x_range, iter.m_text.copy (), iter.m_style_id,
2742 : x_ruler::label_kind::TEXT_WITH_BORDER);
2743 : }
2744 136 : return r;
2745 : }
2746 :
2747 : /* class direction_widget : public leaf_widget. */
2748 :
2749 : /* Paint arrows indicating the direction of the access (read vs write),
2750 : but only in the X-extent corresponding to the region that's actually
2751 : accessed. */
2752 :
2753 : void
2754 68 : direction_widget::paint_to_canvas (canvas &canvas)
2755 : {
2756 68 : const symbolic_bit_range accessed_bits (m_dia_impl.get_op ().get_actual_bits ());
2757 :
2758 68 : const symbolic_bit_range valid_bits (m_dia_impl.get_op ().get_valid_bits ());
2759 :
2760 680 : for (unsigned table_x = 0; table_x < m_btm.get_num_columns (); table_x++)
2761 : {
2762 544 : symbolic_bit_range column_symbolic_bit_range;
2763 544 : if (m_btm.maybe_get_symbolic_bit_range_for_table_x (table_x,
2764 : &column_symbolic_bit_range))
2765 : {
2766 : /* Only paint arrows in the accessed region. */
2767 447 : if (!accessed_bits.access_range_contains_p (column_symbolic_bit_range))
2768 167 : continue;
2769 : /* Are we within the valid region? */
2770 280 : const bool is_valid
2771 280 : (valid_bits.access_range_contains_p (column_symbolic_bit_range));
2772 280 : const style::id_t style_id
2773 280 : = m_dia_impl.get_style_id_for_validity (is_valid);
2774 280 : const canvas::range_t x_canvas_range
2775 280 : = m_dia_impl.get_canvas_x_range (table::range_t (table_x,
2776 280 : table_x + 1));
2777 280 : const int canvas_x = x_canvas_range.get_midpoint ();
2778 280 : m_dia_impl.get_theme ().paint_y_arrow
2779 280 : (canvas,
2780 : canvas_x,
2781 : canvas::range_t (get_y_range ()),
2782 280 : (m_dia_impl.get_op ().m_dir == access_direction::read
2783 280 : ? theme::y_arrow_dir::UP
2784 : : theme::y_arrow_dir::DOWN),
2785 : style_id);
2786 : }
2787 : }
2788 68 : }
2789 :
2790 : /* class access_diagram : public text_art::wrapper_widget. */
2791 :
2792 : /* To hide the implementation details, this is merely a wrapper around
2793 : an access_diagram_impl. */
2794 :
2795 68 : access_diagram::access_diagram (const access_operation &op,
2796 : diagnostics::paths::event_id_t region_creation_event_id,
2797 : style_manager &sm,
2798 : const theme &theme,
2799 : logger *logger)
2800 : : wrapper_widget
2801 68 : (std::make_unique <access_diagram_impl> (op,
2802 : region_creation_event_id,
2803 : sm,
2804 : theme,
2805 68 : logger))
2806 : {
2807 68 : }
2808 :
2809 : #if CHECKING_P
2810 :
2811 : namespace selftest {
2812 :
2813 : /* Run all of the selftests within this file. */
2814 :
2815 : void
2816 4 : analyzer_access_diagram_cc_tests ()
2817 : {
2818 : // Empty
2819 4 : }
2820 :
2821 : } // namespace selftest
2822 :
2823 : #endif /* CHECKING_P */
2824 :
2825 : } // namespace ana
2826 :
2827 : #endif /* #if ENABLE_ANALYZER */
|