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, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   5    2009, 2010 Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tree.h"
  27 #include "diagnostic.h"
  28 #include "tree-pretty-print.h"
  29 #include "tree-diagnostic.h"
  30 #include "tree-pass.h" /* TDF_DIAGNOSTIC */
  31 #include "langhooks.h"
  32 #include "langhooks-def.h"
  33 #include "vec.h"
  34 #include "intl.h"
  35
  36 /* Prints out, if necessary, the name of the current function
  37    that caused an error.  Called from all error and warning functions.  */
  38 void
  39 diagnostic_report_current_function (diagnostic_context *context,
  40                                     diagnostic_info *diagnostic)
  41 {
  42   diagnostic_report_current_module (context, diagnostic->location);
  43   lang_hooks.print_error_function (context, input_filename, diagnostic);
  44 }
  45
  46 static void
  47 default_tree_diagnostic_starter (diagnostic_context *context,
  48                                  diagnostic_info *diagnostic)
  49 {
  50   diagnostic_report_current_function (context, diagnostic);
  51   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
  52                                                             diagnostic));
  53 }
  54
  55 /* This is a pair made of a location and the line map it originated
  56    from.  It's used in the maybe_unwind_expanded_macro_loc function
  57    below.  */
  58 typedef struct
  59 {
  60   const struct line_map *map;
  61   source_location where;
  62 } loc_map_pair;
  63
  64 DEF_VEC_O (loc_map_pair);
  65 DEF_VEC_ALLOC_O (loc_map_pair, heap);
  66
  67 /* Unwind the different macro expansions that lead to the token which
  68    location is WHERE and emit diagnostics showing the resulting
  69    unwound macro expansion trace.  Let's look at an example to see how
  70    the trace looks like.  Suppose we have this piece of code,
  71    artificially annotated with the line numbers to increase
  72    legibility:
  73
  74     $ cat -n test.c
  75       1    #define OPERATE(OPRD1, OPRT, OPRD2) \
  76       2      OPRD1 OPRT OPRD2;
  77       3
  78       4    #define SHIFTL(A,B) \
  79       5      OPERATE (A,<<,B)
  80       6
  81       7    #define MULT(A) \
  82       8      SHIFTL (A,1)
  83       9
  84      10    void
  85      11    g ()
  86      12    {
  87      13      MULT (1.0);// 1.0 << 1; <-- so this is an error.
  88      14    }
  89
  90    Here is the diagnostic that we want the compiler to generate:
  91
  92     test.c: In function 'g':
  93     test.c:5:14: error: invalid operands to binary << (have 'double' and 'int')
  94     test.c:2:9: note: in expansion of macro 'OPERATE'
  95     test.c:5:3: note: expanded from here
  96     test.c:5:14: note: in expansion of macro 'SHIFTL'
  97     test.c:8:3: note: expanded from here
  98     test.c:8:3: note: in expansion of macro 'MULT'
  99     test.c:13:3: note: expanded from here
 100
 101    The part that goes from the third to the eighth line of this
 102    diagnostic (the lines containing the 'note:' string) is called the
 103    unwound macro expansion trace.  That's the part generated by this
 104    function.  */
 105
 106 static void
 107 maybe_unwind_expanded_macro_loc (diagnostic_context *context,
 108                                  diagnostic_info *diagnostic,
 109                                  source_location where)
 110 {
 111   const struct line_map *map;
 112   VEC(loc_map_pair,heap) *loc_vec = NULL;
 113   unsigned ix;
 114   loc_map_pair loc, *iter;
 115
 116   map = linemap_lookup (line_table, where);
 117   if (!linemap_macro_expansion_map_p (map))
 118     return;
 119
 120   /* Let's unwind the macros that got expanded and led to the token
 121      which location is WHERE.  We are going to store these macros into
 122      LOC_VEC, so that we can later walk it at our convenience to
 123      display a somewhat meaningful trace of the macro expansion
 124      history to the user.  Note that the first macro of the trace
 125      (which is OPERATE in the example above) is going to be stored at
 126      the beginning of LOC_VEC.  */
 127
 128   do
 129     {
 130       loc.where = where;
 131       loc.map = map;
 132
 133       VEC_safe_push (loc_map_pair, heap, loc_vec, &loc);
 134
 135       /* WHERE is the location of a token inside the expansion of a
 136          macro.  MAP is the map holding the locations of that macro
 137          expansion.  Let's get the location of the token inside the
 138          context that triggered the expansion of this macro.
 139          This is basically how we go "down" in the trace of macro
 140          expansions that led to WHERE.  */
 141       where = linemap_unwind_toward_expansion (line_table, where, &map);
 142     } while (linemap_macro_expansion_map_p (map));
 143
 144   /* Now map is set to the map of the location in the source that
 145      first triggered the macro expansion.  This must be an ordinary map.  */
 146
 147   /* Walk LOC_VEC and print the macro expansion trace, unless the
 148      first macro which expansion triggered this trace was expanded
 149      inside a system header.  */
 150   if (!LINEMAP_SYSP (map))
 151     FOR_EACH_VEC_ELT (loc_map_pair, loc_vec, ix, iter)
 152       {
 153         source_location resolved_def_loc = 0, resolved_exp_loc = 0;
 154         diagnostic_t saved_kind;
 155         const char *saved_prefix;
 156         source_location saved_location;
 157
 158         /* Okay, now here is what we want.  For each token resulting
 159            from macro expansion we want to show: 1/ where in the
 160            definition of the macro the token comes from; 2/ where the
 161            macro got expanded.  */
 162
 163         /* Resolve the location iter->where into the locus 1/ of the
 164            comment above.  */
 165         resolved_def_loc =
 166           linemap_resolve_location (line_table, iter->where,
 167                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 168
 169         /* Don't print trace for locations that are reserved or from
 170            within a system header.  */
 171         {
 172           const struct line_map *m = NULL;
 173           source_location l = linemap_resolve_location (line_table, resolved_def_loc,
 174                                                         LRK_SPELLING_LOCATION,
 175                                                         &m);
 176           if (l < RESERVED_LOCATION_COUNT
 177               || LINEMAP_SYSP (m))
 178             continue;
 179         }
 180
 181         /* Resolve the location of the expansion point of the macro
 182            which expansion gave the token represented by def_loc.
 183            This is the locus 2/ of the earlier comment.  */
 184         resolved_exp_loc =
 185           linemap_resolve_location (line_table,
 186                                     MACRO_MAP_EXPANSION_POINT_LOCATION (iter->map),
 187                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 188
 189         saved_kind = diagnostic->kind;
 190         saved_prefix = pp_get_prefix (context->printer);
 191         saved_location = diagnostic->location;
 192
 193         diagnostic->kind = DK_NOTE;
 194         diagnostic->location = resolved_def_loc;
 195         pp_set_prefix (context->printer,
 196                        diagnostic_build_prefix (context, diagnostic));
 197         pp_newline (context->printer);
 198         pp_printf (context->printer, "in expansion of macro '%s'",
 199                    linemap_map_get_macro_name (iter->map));
 200         pp_destroy_prefix (context->printer);
 201         diagnostic_show_locus (context, diagnostic);
 202
 203         diagnostic->location = resolved_exp_loc;
 204         pp_set_prefix (context->printer,
 205                        diagnostic_build_prefix (context, diagnostic));
 206         pp_newline (context->printer);
 207         pp_string (context->printer, "expanded from here");
 208         pp_destroy_prefix (context->printer);
 209         diagnostic_show_locus (context, diagnostic);
 210
 211         diagnostic->kind = saved_kind;
 212         diagnostic->location = saved_location;
 213         pp_set_prefix (context->printer, saved_prefix);
 214       }
 215
 216   VEC_free (loc_map_pair, heap, loc_vec);
 217 }
 218
 219 /*  This is a diagnostic finalizer implementation that is aware of
 220     virtual locations produced by libcpp.
 221
 222     It has to be called by the diagnostic finalizer of front ends that
 223     uses libcpp and wish to get diagnostics involving tokens resulting
 224     from macro expansion.
 225
 226     For a given location, if said location belongs to a token
 227     resulting from a macro expansion, this starter prints the context
 228     of the token.  E.g, for multiply nested macro expansion, it
 229     unwinds the nested macro expansions and prints them in a manner
 230     that is similar to what is done for function call stacks, or
 231     template instantiation contexts.  */
 232 void
 233 virt_loc_aware_diagnostic_finalizer (diagnostic_context *context,
 234                                      diagnostic_info *diagnostic)
 235 {
 236   maybe_unwind_expanded_macro_loc (context, diagnostic,
 237                                    diagnostic->location);
 238 }
 239
 240 /* Default tree printer.   Handles declarations only.  */
 241 static bool
 242 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
 243                       int precision, bool wide, bool set_locus, bool hash)
 244 {
 245   tree t;
 246
 247   /* FUTURE: %+x should set the locus.  */
 248   if (precision != 0 || wide || hash)
 249     return false;
 250
 251   switch (*spec)
 252     {
 253     case 'E':
 254       t = va_arg (*text->args_ptr, tree);
 255       if (TREE_CODE (t) == IDENTIFIER_NODE)
 256         {
 257           pp_identifier (pp, IDENTIFIER_POINTER (t));
 258           return true;
 259         }
 260       break;
 261
 262     case 'D':
 263       t = va_arg (*text->args_ptr, tree);
 264       if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
 265         t = DECL_DEBUG_EXPR (t);
 266       break;
 267
 268     case 'F':
 269     case 'T':
 270       t = va_arg (*text->args_ptr, tree);
 271       break;
 272
 273     case 'K':
 274       percent_K_format (text);
 275       return true;
 276
 277     default:
 278       return false;
 279     }
 280
 281   if (set_locus && text->locus)
 282     *text->locus = DECL_SOURCE_LOCATION (t);
 283
 284   if (DECL_P (t))
 285     {
 286       const char *n = DECL_NAME (t)
 287         ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
 288         : _("<anonymous>");
 289       pp_string (pp, n);
 290     }
 291   else
 292     dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
 293
 294   return true;
 295 }
 296
 297 /* Sets CONTEXT to use language independent diagnostics.  */
 298 void
 299 tree_diagnostics_defaults (diagnostic_context *context)
 300 {
 301   diagnostic_starter (context) = default_tree_diagnostic_starter;
 302   diagnostic_finalizer (context) = default_diagnostic_finalizer;
 303   diagnostic_format_decoder (context) = default_tree_printer;
 304 }