gcc/simple-diagnostic-path.cc

   1 /* Concrete classes for implementing diagnostic paths.
   2    Copyright (C) 2019-2024 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 under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 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
  22 #include "config.h"
  23 #define INCLUDE_MEMORY
  24 #define INCLUDE_VECTOR
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tree.h"
  28 #include "version.h"
  29 #include "demangle.h"
  30 #include "intl.h"
  31 #include "backtrace.h"
  32 #include "diagnostic.h"
  33 #include "simple-diagnostic-path.h"
  34 #include "selftest.h"
  35
  36 /* class simple_diagnostic_path : public diagnostic_path.  */
  37
  38 simple_diagnostic_path::simple_diagnostic_path (pretty_printer *event_pp)
  39 : m_event_pp (event_pp),
  40   m_localize_events (true)
  41 {
  42   add_thread ("main");
  43 }
  44
  45 /* Implementation of diagnostic_path::num_events vfunc for
  46    simple_diagnostic_path: simply get the number of events in the vec.  */
  47
  48 unsigned
  49 simple_diagnostic_path::num_events () const
  50 {
  51   return m_events.length ();
  52 }
  53
  54 /* Implementation of diagnostic_path::get_event vfunc for
  55    simple_diagnostic_path: simply return the event in the vec.  */
  56
  57 const diagnostic_event &
  58 simple_diagnostic_path::get_event (int idx) const
  59 {
  60   return *m_events[idx];
  61 }
  62
  63 unsigned
  64 simple_diagnostic_path::num_threads () const
  65 {
  66   return m_threads.length ();
  67 }
  68
  69 const diagnostic_thread &
  70 simple_diagnostic_path::get_thread (diagnostic_thread_id_t idx) const
  71 {
  72   return *m_threads[idx];
  73 }
  74
  75 bool
  76 simple_diagnostic_path::same_function_p (int event_idx_a,
  77                                          int event_idx_b) const
  78 {
  79   return (m_events[event_idx_a]->get_fndecl ()
  80           == m_events[event_idx_b]->get_fndecl ());
  81 }
  82
  83 diagnostic_thread_id_t
  84 simple_diagnostic_path::add_thread (const char *name)
  85 {
  86   m_threads.safe_push (new simple_diagnostic_thread (name));
  87   return m_threads.length () - 1;
  88 }
  89
  90 /* Add an event to this path at LOC within function FNDECL at
  91    stack depth DEPTH.
  92
  93    Use m_context's printer to format FMT, as the text of the new
  94    event.  Localize FMT iff m_localize_events is set.
  95
  96    Return the id of the new event.  */
  97
  98 diagnostic_event_id_t
  99 simple_diagnostic_path::add_event (location_t loc, tree fndecl, int depth,
 100                                    const char *fmt, ...)
 101 {
 102   pretty_printer *pp = m_event_pp;
 103   pp_clear_output_area (pp);
 104
 105   rich_location rich_loc (line_table, UNKNOWN_LOCATION);
 106
 107   va_list ap;
 108
 109   va_start (ap, fmt);
 110
 111   text_info ti (m_localize_events ? _(fmt) : fmt,
 112                 &ap, 0, nullptr, &rich_loc);
 113   pp_format (pp, &ti);
 114   pp_output_formatted_text (pp);
 115
 116   va_end (ap);
 117
 118   simple_diagnostic_event *new_event
 119     = new simple_diagnostic_event (loc, fndecl, depth, pp_formatted_text (pp));
 120   m_events.safe_push (new_event);
 121
 122   pp_clear_output_area (pp);
 123
 124   return diagnostic_event_id_t (m_events.length () - 1);
 125 }
 126
 127 diagnostic_event_id_t
 128 simple_diagnostic_path::add_thread_event (diagnostic_thread_id_t thread_id,
 129                                           location_t loc,
 130                                           tree fndecl,
 131                                           int depth,
 132                                           const char *fmt, ...)
 133 {
 134   pretty_printer *pp = m_event_pp;
 135   pp_clear_output_area (pp);
 136
 137   rich_location rich_loc (line_table, UNKNOWN_LOCATION);
 138
 139   va_list ap;
 140
 141   va_start (ap, fmt);
 142
 143   text_info ti (_(fmt), &ap, 0, nullptr, &rich_loc);
 144
 145   pp_format (pp, &ti);
 146   pp_output_formatted_text (pp);
 147
 148   va_end (ap);
 149
 150   simple_diagnostic_event *new_event
 151     = new simple_diagnostic_event (loc, fndecl, depth, pp_formatted_text (pp),
 152                                    thread_id);
 153   m_events.safe_push (new_event);
 154
 155   pp_clear_output_area (pp);
 156
 157   return diagnostic_event_id_t (m_events.length () - 1);
 158 }
 159
 160 /* Mark the most recent event on this path (which must exist) as being
 161    connected to the next one to be added.  */
 162
 163 void
 164 simple_diagnostic_path::connect_to_next_event ()
 165 {
 166   gcc_assert (m_events.length () > 0);
 167   m_events[m_events.length () - 1]->connect_to_next_event ();
 168 }
 169
 170 /* struct simple_diagnostic_event.  */
 171
 172 /* simple_diagnostic_event's ctor.  */
 173
 174 simple_diagnostic_event::
 175 simple_diagnostic_event (location_t loc,
 176                          tree fndecl,
 177                          int depth,
 178                          const char *desc,
 179                          diagnostic_thread_id_t thread_id)
 180 : m_loc (loc), m_fndecl (fndecl), m_logical_loc (fndecl),
 181   m_depth (depth), m_desc (xstrdup (desc)),
 182   m_connected_to_next_event (false),
 183   m_thread_id (thread_id)
 184 {
 185 }
 186
 187 /* simple_diagnostic_event's dtor.  */
 188
 189 simple_diagnostic_event::~simple_diagnostic_event ()
 190 {
 191   free (m_desc);
 192 }
 193
 194 #if CHECKING_P
 195
 196 namespace selftest {
 197
 198 static void
 199 test_intraprocedural_path (pretty_printer *event_pp)
 200 {
 201   tree fntype_void_void
 202     = build_function_type_array (void_type_node, 0, NULL);
 203   tree fndecl_foo = build_fn_decl ("foo", fntype_void_void);
 204
 205   simple_diagnostic_path path (event_pp);
 206   path.add_event (UNKNOWN_LOCATION, fndecl_foo, 0, "first %qs", "free");
 207   path.add_event (UNKNOWN_LOCATION, fndecl_foo, 0, "double %qs", "free");
 208
 209   ASSERT_EQ (path.num_events (), 2);
 210   ASSERT_EQ (path.num_threads (), 1);
 211   ASSERT_FALSE (path.interprocedural_p ());
 212   ASSERT_STREQ (path.get_event (0).get_desc (false).get (), "first `free'");
 213   ASSERT_STREQ (path.get_event (1).get_desc (false).get (), "double `free'");
 214 }
 215
 216 /* Run all of the selftests within this file.  */
 217
 218 void
 219 simple_diagnostic_path_cc_tests ()
 220 {
 221   /* In a few places we use the global dc's printer to determine
 222      colorization so ensure this off during the tests.  */
 223   pretty_printer *global_pp = global_dc->m_printer;
 224   const bool saved_show_color = pp_show_color (global_pp);
 225   pp_show_color (global_pp) = false;
 226
 227   auto_fix_quotes fix_quotes;
 228   std::unique_ptr<pretty_printer> event_pp
 229     = std::unique_ptr<pretty_printer> (global_pp->clone ());
 230
 231   test_intraprocedural_path (event_pp.get ());
 232
 233   pp_show_color (global_pp) = saved_show_color;
 234 }
 235
 236 } // namespace selftest
 237
 238 #endif /* #if CHECKING_P */