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-2017 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 "tree-diagnostic.h"
  29 #include "langhooks.h"
  30 #include "intl.h"
  31
  32 /* Prints out, if necessary, the name of the current function
  33    that caused an error.  Called from all error and warning functions.  */
  34 void
  35 diagnostic_report_current_function (diagnostic_context *context,
  36                                     diagnostic_info *diagnostic)
  37 {
  38   diagnostic_report_current_module (context, diagnostic_location (diagnostic));
  39   lang_hooks.print_error_function (context, LOCATION_FILE (input_location),
  40                                    diagnostic);
  41 }
  42
  43 static void
  44 default_tree_diagnostic_starter (diagnostic_context *context,
  45                                  diagnostic_info *diagnostic)
  46 {
  47   diagnostic_report_current_function (context, diagnostic);
  48   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
  49                                                             diagnostic));
  50 }
  51
  52 /* This is a pair made of a location and the line map it originated
  53    from.  It's used in the maybe_unwind_expanded_macro_loc function
  54    below.  */
  55 struct loc_map_pair
  56 {
  57   const line_map_macro *map;
  58   source_location where;
  59 };
  60
  61
  62 /* Unwind the different macro expansions that lead to the token which
  63    location is WHERE and emit diagnostics showing the resulting
  64    unwound macro expansion trace.  Let's look at an example to see how
  65    the trace looks like.  Suppose we have this piece of code,
  66    artificially annotated with the line numbers to increase
  67    legibility:
  68
  69     $ cat -n test.c
  70       1    #define OPERATE(OPRD1, OPRT, OPRD2) \
  71       2      OPRD1 OPRT OPRD2;
  72       3
  73       4    #define SHIFTL(A,B) \
  74       5      OPERATE (A,<<,B)
  75       6
  76       7    #define MULT(A) \
  77       8      SHIFTL (A,1)
  78       9
  79      10    void
  80      11    g ()
  81      12    {
  82      13      MULT (1.0);// 1.0 << 1; <-- so this is an error.
  83      14    }
  84
  85    Here is the diagnostic that we want the compiler to generate:
  86
  87     test.c: In function ‘g’:
  88     test.c:5:14: error: invalid operands to binary << (have ‘double’ and ‘int’)
  89     test.c:2:9: note: in definition of macro 'OPERATE'
  90     test.c:8:3: note: in expansion of macro 'SHIFTL'
  91     test.c:13:3: note: in expansion of macro 'MULT'
  92
  93    The part that goes from the third to the fifth line of this
  94    diagnostic (the lines containing the 'note:' string) is called the
  95    unwound macro expansion trace.  That's the part generated by this
  96    function.  */
  97
  98 static void
  99 maybe_unwind_expanded_macro_loc (diagnostic_context *context,
 100                                  const diagnostic_info *diagnostic,
 101                                  source_location 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   map = linemap_lookup (line_table, where);
 109   if (!linemap_macro_expansion_map_p (map))
 110     return;
 111
 112   /* Let's unwind the macros that got expanded and led to the token
 113      which location is WHERE.  We are going to store these macros into
 114      LOC_VEC, so that we can later walk it at our convenience to
 115      display a somewhat meaningful trace of the macro expansion
 116      history to the user.  Note that the first macro of the trace
 117      (which is OPERATE in the example above) is going to be stored at
 118      the beginning of LOC_VEC.  */
 119
 120   do
 121     {
 122       loc.where = where;
 123       loc.map = linemap_check_macro (map);
 124
 125       loc_vec.safe_push (loc);
 126
 127       /* WHERE is the location of a token inside the expansion of a
 128          macro.  MAP is the map holding the locations of that macro
 129          expansion.  Let's get the location of the token inside the
 130          context that triggered the expansion of this macro.
 131          This is basically how we go "down" in the trace of macro
 132          expansions that led to WHERE.  */
 133       where = linemap_unwind_toward_expansion (line_table, where, &map);
 134     } while (linemap_macro_expansion_map_p (map));
 135
 136   /* Now map is set to the map of the location in the source that
 137      first triggered the macro expansion.  This must be an ordinary map.  */
 138   const line_map_ordinary *ord_map = linemap_check_ordinary (map);
 139
 140   /* Walk LOC_VEC and print the macro expansion trace, unless the
 141      first macro which expansion triggered this trace was expanded
 142      inside a system header.  */
 143   int saved_location_line =
 144     expand_location_to_spelling_point (diagnostic_location (diagnostic)).line;
 145
 146   if (!LINEMAP_SYSP (ord_map))
 147     FOR_EACH_VEC_ELT (loc_vec, ix, iter)
 148       {
 149         /* Sometimes, in the unwound macro expansion trace, we want to
 150            print a part of the context that shows where, in the
 151            definition of the relevant macro, is the token (we are
 152            looking at) used.  That is the case in the introductory
 153            comment of this function, where we print:
 154
 155                test.c:2:9: note: in definition of macro 'OPERATE'.
 156
 157            We print that "macro definition context" because the
 158            diagnostic line (emitted by the call to
 159            pp_ouput_formatted_text in diagnostic_report_diagnostic):
 160
 161                test.c:5:14: error: invalid operands to binary << (have ‘double’ and ‘int’)
 162
 163            does not point into the definition of the macro where the
 164            token '<<' (that is an argument to the function-like macro
 165            OPERATE) is used.  So we must "display" the line of that
 166            macro definition context to the user somehow.
 167
 168            A contrario, when the first interesting diagnostic line
 169            points into the definition of the macro, we don't need to
 170            display any line for that macro definition in the trace
 171            anymore, otherwise it'd be redundant.  */
 172
 173         /* Okay, now here is what we want.  For each token resulting
 174            from macro expansion we want to show: 1/ where in the
 175            definition of the macro the token comes from; 2/ where the
 176            macro got expanded.  */
 177
 178         /* Resolve the location iter->where into the locus 1/ of the
 179            comment above.  */
 180         source_location resolved_def_loc =
 181           linemap_resolve_location (line_table, iter->where,
 182                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 183
 184         /* Don't print trace for locations that are reserved or from
 185            within a system header.  */
 186         const line_map_ordinary *m = NULL;
 187         source_location l =
 188           linemap_resolve_location (line_table, resolved_def_loc,
 189                                     LRK_SPELLING_LOCATION,  &m);
 190         if (l < RESERVED_LOCATION_COUNT || LINEMAP_SYSP (m))
 191           continue;
 192
 193         /* We need to print the context of the macro definition only
 194            when the locus of the first displayed diagnostic (displayed
 195            before this trace) was inside the definition of the
 196            macro.  */
 197         int resolved_def_loc_line = SOURCE_LINE (m, l);
 198         if (ix == 0 && saved_location_line != resolved_def_loc_line)
 199           {
 200             diagnostic_append_note (context, resolved_def_loc,
 201                                     "in definition of macro %qs",
 202                                     linemap_map_get_macro_name (iter->map));
 203             /* At this step, as we've printed the context of the macro
 204                definition, we don't want to print the context of its
 205                expansion, otherwise, it'd be redundant.  */
 206             continue;
 207           }
 208
 209         /* Resolve the location of the expansion point of the macro
 210            which expansion gave the token represented by def_loc.
 211            This is the locus 2/ of the earlier comment.  */
 212         source_location resolved_exp_loc =
 213           linemap_resolve_location (line_table,
 214                                     MACRO_MAP_EXPANSION_POINT_LOCATION (iter->map),
 215                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 216
 217         diagnostic_append_note (context, resolved_exp_loc,
 218                                 "in expansion of macro %qs",
 219                                 linemap_map_get_macro_name (iter->map));
 220       }
 221 }
 222
 223 /*  This is a diagnostic finalizer implementation that is aware of
 224     virtual locations produced by libcpp.
 225
 226     It has to be called by the diagnostic finalizer of front ends that
 227     uses libcpp and wish to get diagnostics involving tokens resulting
 228     from macro expansion.
 229
 230     For a given location, if said location belongs to a token
 231     resulting from a macro expansion, this starter prints the context
 232     of the token.  E.g, for multiply nested macro expansion, it
 233     unwinds the nested macro expansions and prints them in a manner
 234     that is similar to what is done for function call stacks, or
 235     template instantiation contexts.  */
 236 void
 237 virt_loc_aware_diagnostic_finalizer (diagnostic_context *context,
 238                                      diagnostic_info *diagnostic)
 239 {
 240   maybe_unwind_expanded_macro_loc (context, diagnostic,
 241                                    diagnostic_location (diagnostic));
 242 }
 243
 244 /* Default tree printer.   Handles declarations only.  */
 245 bool
 246 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 247                       int precision, bool wide, bool set_locus, bool hash,
 248                       bool, const char **)
 249 {
 250   tree t;
 251
 252   /* FUTURE: %+x should set the locus.  */
 253   if (precision != 0 || wide || hash)
 254     return false;
 255
 256   switch (*spec)
 257     {
 258     case 'E':
 259       t = va_arg (*text->args_ptr, tree);
 260       if (TREE_CODE (t) == IDENTIFIER_NODE)
 261         {
 262           pp_identifier (pp, IDENTIFIER_POINTER (t));
 263           return true;
 264         }
 265       break;
 266
 267     case 'D':
 268       t = va_arg (*text->args_ptr, tree);
 269       if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
 270         t = DECL_DEBUG_EXPR (t);
 271       break;
 272
 273     case 'F':
 274     case 'T':
 275       t = va_arg (*text->args_ptr, tree);
 276       break;
 277
 278     case 'K':
 279       percent_K_format (text);
 280       return true;
 281
 282     default:
 283       return false;
 284     }
 285
 286   if (set_locus)
 287     text->set_location (0, DECL_SOURCE_LOCATION (t), true);
 288
 289   if (DECL_P (t))
 290     {
 291       const char *n = DECL_NAME (t)
 292         ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
 293         : _("<anonymous>");
 294       pp_string (pp, n);
 295     }
 296   else
 297     dump_generic_node (pp, t, 0, TDF_SLIM, 0);
 298
 299   return true;
 300 }
 301
 302 /* Sets CONTEXT to use language independent diagnostics.  */
 303 void
 304 tree_diagnostics_defaults (diagnostic_context *context)
 305 {
 306   diagnostic_starter (context) = default_tree_diagnostic_starter;
 307   diagnostic_finalizer (context) = default_diagnostic_finalizer;
 308   diagnostic_format_decoder (context) = default_tree_printer;
 309 }