LCOV - code coverage report
Current view: top level - gcc/analyzer - call-summary.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 61.8 % 626 387
Test Date: 2026-11-14 16:39:50 Functions: 70.8 % 24 17
Legend: Lines:     hit not hit

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

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.