LCOV - code coverage report
Current view: top level - gcc/analyzer - access-diagram.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 88.1 % 1258 1108
Test Date: 2026-11-14 16:39:50 Functions: 89.5 % 95 85
Legend: Lines:     hit not hit

            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 &reg, 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 */
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.