gcc/tree-diagnostic.c

   1 /* Language-independent diagnostic subroutines for the GNU Compiler
   2    Collection that are only for use in the compilers proper and not
   3    the driver or other programs.
   4    Copyright (C) 1999-2021 Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tree.h"
  26 #include "diagnostic.h"
  27 #include "tree-pretty-print.h"
  28 #include "gimple-pretty-print.h"
  29 #include "tree-diagnostic.h"
  30 #include "langhooks.h"
  31 #include "intl.h"
  32
  33 /* Prints out, if necessary, the name of the current function
  34    that caused an error.  Called from all error and warning functions.  */
  35 void
  36 diagnostic_report_current_function (diagnostic_context *context,
  37                                     diagnostic_info *diagnostic)
  38 {
  39   location_t loc = diagnostic_location (diagnostic);
  40   diagnostic_report_current_module (context, loc);
  41   lang_hooks.print_error_function (context, LOCATION_FILE (loc), diagnostic);
  42 }
  43
  44 static void
  45 default_tree_diagnostic_starter (diagnostic_context *context,
  46                                  diagnostic_info *diagnostic)
  47 {
  48   diagnostic_report_current_function (context, diagnostic);
  49   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
  50                                                             diagnostic));
  51 }
  52
  53 /* This is a pair made of a location and the line map it originated
  54    from.  It's used in the maybe_unwind_expanded_macro_loc function
  55    below.  */
  56 struct loc_map_pair
  57 {
  58   const line_map_macro *map;
  59   location_t where;
  60 };
  61
  62
  63 /* Unwind the different macro expansions that lead to the token which
  64    location is WHERE and emit diagnostics showing the resulting
  65    unwound macro expansion trace.  Let's look at an example to see how
  66    the trace looks like.  Suppose we have this piece of code,
  67    artificially annotated with the line numbers to increase
  68    legibility:
  69
  70     $ cat -n test.c
  71       1    #define OPERATE(OPRD1, OPRT, OPRD2) \
  72       2      OPRD1 OPRT OPRD2;
  73       3
  74       4    #define SHIFTL(A,B) \
  75       5      OPERATE (A,<<,B)
  76       6
  77       7    #define MULT(A) \
  78       8      SHIFTL (A,1)
  79       9
  80      10    void
  81      11    g ()
  82      12    {
  83      13      MULT (1.0);// 1.0 << 1; <-- so this is an error.
  84      14    }
  85
  86    Here is the diagnostic that we want the compiler to generate:
  87
  88     test.c: In function ‘g’:
  89     test.c:5:14: error: invalid operands to binary << (have ‘double’ and ‘int’)
  90     test.c:2:9: note: in definition of macro 'OPERATE'
  91     test.c:8:3: note: in expansion of macro 'SHIFTL'
  92     test.c:13:3: note: in expansion of macro 'MULT'
  93
  94    The part that goes from the third to the fifth line of this
  95    diagnostic (the lines containing the 'note:' string) is called the
  96    unwound macro expansion trace.  That's the part generated by this
  97    function.  */
  98
  99 void
 100 maybe_unwind_expanded_macro_loc (diagnostic_context *context,
 101                                  location_t where)
 102 {
 103   const struct line_map *map;
 104   auto_vec<loc_map_pair> loc_vec;
 105   unsigned ix;
 106   loc_map_pair loc, *iter;
 107
 108   const location_t original_loc = where;
 109
 110   map = linemap_lookup (line_table, where);
 111   if (!linemap_macro_expansion_map_p (map))
 112     return;
 113
 114   /* Let's unwind the macros that got expanded and led to the token
 115      which location is WHERE.  We are going to store these macros into
 116      LOC_VEC, so that we can later walk it at our convenience to
 117      display a somewhat meaningful trace of the macro expansion
 118      history to the user.  Note that the first macro of the trace
 119      (which is OPERATE in the example above) is going to be stored at
 120      the beginning of LOC_VEC.  */
 121
 122   do
 123     {
 124       loc.where = where;
 125       loc.map = linemap_check_macro (map);
 126
 127       loc_vec.safe_push (loc);
 128
 129       /* WHERE is the location of a token inside the expansion of a
 130          macro.  MAP is the map holding the locations of that macro
 131          expansion.  Let's get the location of the token inside the
 132          context that triggered the expansion of this macro.
 133          This is basically how we go "down" in the trace of macro
 134          expansions that led to WHERE.  */
 135       where = linemap_unwind_toward_expansion (line_table, where, &map);
 136     } while (linemap_macro_expansion_map_p (map));
 137
 138   /* Now map is set to the map of the location in the source that
 139      first triggered the macro expansion.  This must be an ordinary map.  */
 140   const line_map_ordinary *ord_map = linemap_check_ordinary (map);
 141
 142   /* Walk LOC_VEC and print the macro expansion trace, unless the
 143      first macro which expansion triggered this trace was expanded
 144      inside a system header.  */
 145   int saved_location_line =
 146     expand_location_to_spelling_point (original_loc).line;
 147
 148   if (!LINEMAP_SYSP (ord_map))
 149     FOR_EACH_VEC_ELT (loc_vec, ix, iter)
 150       {
 151         /* Sometimes, in the unwound macro expansion trace, we want to
 152            print a part of the context that shows where, in the
 153            definition of the relevant macro, is the token (we are
 154            looking at) used.  That is the case in the introductory
 155            comment of this function, where we print:
 156
 157                test.c:2:9: note: in definition of macro 'OPERATE'.
 158
 159            We print that "macro definition context" because the
 160            diagnostic line (emitted by the call to
 161            pp_ouput_formatted_text in diagnostic_report_diagnostic):
 162
 163                test.c:5:14: error: invalid operands to binary << (have ‘double’ and ‘int’)
 164
 165            does not point into the definition of the macro where the
 166            token '<<' (that is an argument to the function-like macro
 167            OPERATE) is used.  So we must "display" the line of that
 168            macro definition context to the user somehow.
 169
 170            A contrario, when the first interesting diagnostic line
 171            points into the definition of the macro, we don't need to
 172            display any line for that macro definition in the trace
 173            anymore, otherwise it'd be redundant.  */
 174
 175         /* Okay, now here is what we want.  For each token resulting
 176            from macro expansion we want to show: 1/ where in the
 177            definition of the macro the token comes from; 2/ where the
 178            macro got expanded.  */
 179
 180         /* Resolve the location iter->where into the locus 1/ of the
 181            comment above.  */
 182         location_t resolved_def_loc =
 183           linemap_resolve_location (line_table, iter->where,
 184                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 185
 186         /* Don't print trace for locations that are reserved or from
 187            within a system header.  */
 188         const line_map_ordinary *m = NULL;
 189         location_t l =
 190           linemap_resolve_location (line_table, resolved_def_loc,
 191                                     LRK_SPELLING_LOCATION,  &m);
 192         if (l < RESERVED_LOCATION_COUNT || LINEMAP_SYSP (m))
 193           continue;
 194
 195         /* We need to print the context of the macro definition only
 196            when the locus of the first displayed diagnostic (displayed
 197            before this trace) was inside the definition of the
 198            macro.  */
 199         int resolved_def_loc_line = SOURCE_LINE (m, l);
 200         if (ix == 0 && saved_location_line != resolved_def_loc_line)
 201           {
 202             diagnostic_append_note (context, resolved_def_loc,
 203                                     "in definition of macro %qs",
 204                                     linemap_map_get_macro_name (iter->map));
 205             /* At this step, as we've printed the context of the macro
 206                definition, we don't want to print the context of its
 207                expansion, otherwise, it'd be redundant.  */
 208             continue;
 209           }
 210
 211         /* Resolve the location of the expansion point of the macro
 212            which expansion gave the token represented by def_loc.
 213            This is the locus 2/ of the earlier comment.  */
 214         location_t resolved_exp_loc =
 215           linemap_resolve_location (line_table,
 216                                     MACRO_MAP_EXPANSION_POINT_LOCATION (iter->map),
 217                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 218
 219         diagnostic_append_note (context, resolved_exp_loc,
 220                                 "in expansion of macro %qs",
 221                                 linemap_map_get_macro_name (iter->map));
 222       }
 223 }
 224
 225 /*  This is a diagnostic finalizer implementation that is aware of
 226     virtual locations produced by libcpp.
 227
 228     It has to be called by the diagnostic finalizer of front ends that
 229     uses libcpp and wish to get diagnostics involving tokens resulting
 230     from macro expansion.
 231
 232     For a given location, if said location belongs to a token
 233     resulting from a macro expansion, this starter prints the context
 234     of the token.  E.g, for multiply nested macro expansion, it
 235     unwinds the nested macro expansions and prints them in a manner
 236     that is similar to what is done for function call stacks, or
 237     template instantiation contexts.  */
 238 void
 239 virt_loc_aware_diagnostic_finalizer (diagnostic_context *context,
 240                                      diagnostic_info *diagnostic)
 241 {
 242   maybe_unwind_expanded_macro_loc (context, diagnostic_location (diagnostic));
 243 }
 244
 245 /* Default tree printer.   Handles declarations only.  */
 246 bool
 247 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 248                       int precision, bool wide, bool set_locus, bool hash,
 249                       bool *, const char **)
 250 {
 251   tree t;
 252
 253   /* FUTURE: %+x should set the locus.  */
 254   if (precision != 0 || wide || hash)
 255     return false;
 256
 257   switch (*spec)
 258     {
 259     case 'E':
 260       t = va_arg (*text->args_ptr, tree);
 261       if (TREE_CODE (t) == IDENTIFIER_NODE)
 262         {
 263           pp_identifier (pp, IDENTIFIER_POINTER (t));
 264           return true;
 265         }
 266       break;
 267
 268     case 'D':
 269       t = va_arg (*text->args_ptr, tree);
 270       if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
 271         t = DECL_DEBUG_EXPR (t);
 272       break;
 273
 274     case 'F':
 275     case 'T':
 276       t = va_arg (*text->args_ptr, tree);
 277       break;
 278
 279     default:
 280       return false;
 281     }
 282
 283   if (set_locus)
 284     text->set_location (0, DECL_SOURCE_LOCATION (t), SHOW_RANGE_WITH_CARET);
 285
 286   if (DECL_P (t))
 287     {
 288       const char *n = DECL_NAME (t)
 289         ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
 290         : _("<anonymous>");
 291       pp_string (pp, n);
 292     }
 293   else
 294     dump_generic_node (pp, t, 0, TDF_SLIM, 0);
 295
 296   return true;
 297 }
 298
 299 /* Set the locations of call sites along the inlining stack corresponding
 300    to the DIAGNOSTIC location.  */
 301
 302 static void
 303 set_inlining_locations (diagnostic_context *,
 304                         diagnostic_info *diagnostic)
 305 {
 306   location_t loc = diagnostic_location (diagnostic);
 307   tree block = LOCATION_BLOCK (loc);
 308
 309   /* Count the number of locations in system headers.  When all are,
 310      warnings are suppressed by -Wno-system-headers.  Otherwise, they
 311      involve some user code, possibly inlined into a function in a system
 312      header, and are not treated as coming from system headers.  */
 313   unsigned nsyslocs = 0;
 314
 315   /* Use a reference to the vector of locations for convenience.  */
 316   auto &ilocs = diagnostic->m_iinfo.m_ilocs;
 317
 318   while (block && TREE_CODE (block) == BLOCK
 319          && BLOCK_ABSTRACT_ORIGIN (block))
 320     {
 321       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
 322       if (TREE_CODE (ao) == FUNCTION_DECL)
 323         {
 324           if (!diagnostic->m_iinfo.m_ao)
 325             diagnostic->m_iinfo.m_ao = block;
 326
 327           location_t bsloc = BLOCK_SOURCE_LOCATION (block);
 328           ilocs.safe_push (bsloc);
 329           if (in_system_header_at (bsloc))
 330             ++nsyslocs;
 331         }
 332       else if (TREE_CODE (ao) != BLOCK)
 333         break;
 334
 335       block = BLOCK_SUPERCONTEXT (block);
 336     }
 337
 338   if (ilocs.length ())
 339     {
 340       /* When there is an inlining context use the macro expansion
 341          location for the original location and bump up NSYSLOCS if
 342          it's in a system header since it's not counted above.  */
 343       location_t sysloc = expansion_point_location_if_in_system_header (loc);
 344       if (sysloc != loc)
 345         {
 346           loc = sysloc;
 347           ++nsyslocs;
 348         }
 349     }
 350   else
 351     {
 352       /* When there's no inlining context use the original location
 353          and set NSYSLOCS accordingly.  */
 354       nsyslocs = in_system_header_at (loc) != 0;
 355     }
 356
 357   ilocs.safe_push (loc);
 358
 359   /* Set if all locations are in a system header.  */
 360   diagnostic->m_iinfo.m_allsyslocs = nsyslocs == ilocs.length ();
 361
 362   if (tree *ao = pp_ti_abstract_origin (&diagnostic->message))
 363     *ao = (tree)diagnostic->m_iinfo.m_ao;
 364 }
 365
 366 /* Sets CONTEXT to use language independent diagnostics.  */
 367 void
 368 tree_diagnostics_defaults (diagnostic_context *context)
 369 {
 370   diagnostic_starter (context) = default_tree_diagnostic_starter;
 371   diagnostic_finalizer (context) = default_diagnostic_finalizer;
 372   diagnostic_format_decoder (context) = default_tree_printer;
 373   context->print_path = default_tree_diagnostic_path_printer;
 374   context->make_json_for_path = default_tree_make_json_for_path;
 375   context->set_locations_cb = set_inlining_locations;
 376 }