LCOV - code coverage report
Current view: top level - gcc/analyzer - region.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 67.5 % 1180 796
Test Date: 2026-11-14 16:39:50 Functions: 55.7 % 203 113
Legend: Lines:     hit not hit

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

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.