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