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-diagnostic.h"
  29 #include "langhooks.h"
  30 #include "langhooks-def.h"
  31 #include "vec.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   diagnostic_report_current_module (context, diagnostic->location);
  40   lang_hooks.print_error_function (context, input_filename, diagnostic);
  41 }
  42
  43 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 typedef struct
  56 {
  57   const struct line_map *map;
  58   source_location where;
  59 } loc_map_pair;
  60
  61 DEF_VEC_O (loc_map_pair);
  62 DEF_VEC_ALLOC_O (loc_map_pair, heap);
  63
  64 /* Unwind the different macro expansions that lead to the token which
  65    location is WHERE and emit diagnostics showing the resulting
  66    unwound macro expansion trace.  Let's look at an example to see how
  67    the trace looks like.  Suppose we have this piece of code,
  68    artificially annotated with the line numbers to increase
  69    legibility:
  70
  71     $ cat -n test.c
  72       1    #define OPERATE(OPRD1, OPRT, OPRD2) \
  73       2      OPRD1 OPRT OPRD2;
  74       3
  75       4    #define SHIFTL(A,B) \
  76       5      OPERATE (A,<<,B)
  77       6
  78       7    #define MULT(A) \
  79       8      SHIFTL (A,1)
  80       9
  81      10    void
  82      11    g ()
  83      12    {
  84      13      MULT (1.0);// 1.0 << 1; <-- so this is an error.
  85      14    }
  86
  87    Here is the diagnostic that we want the compiler to generate:
  88
  89     test.c: In function 'g':
  90     test.c:5:14: error: invalid operands to binary << (have 'double' and 'int')
  91     test.c:2:9: note: in expansion of macro 'OPERATE'
  92     test.c:5:3: note: expanded from here
  93     test.c:5:14: note: in expansion of macro 'SHIFTL'
  94     test.c:8:3: note: expanded from here
  95     test.c:8:3: note: in expansion of macro 'MULT2'
  96     test.c:13:3: note: expanded from here
  97
  98    The part that goes from the third to the eighth line of this
  99    diagnostic (the lines containing the 'note:' string) is called the
 100    unwound macro expansion trace.  That's the part generated by this
 101    function.
 102
 103    If FIRST_EXP_POINT_MAP is non-null, *FIRST_EXP_POINT_MAP is set to
 104    the map of the location in the source that first triggered the
 105    macro expansion.  This must be an ordinary map.  */
 106
 107 static void
 108 maybe_unwind_expanded_macro_loc (diagnostic_context *context,
 109                                  diagnostic_info *diagnostic,
 110                                  source_location where,
 111                                  const struct line_map **first_exp_point_map)
 112 {
 113   const struct line_map *map;
 114   VEC(loc_map_pair,heap) *loc_vec = NULL;
 115   unsigned ix;
 116   loc_map_pair loc, *iter;
 117
 118   map = linemap_lookup (line_table, where);
 119   if (!linemap_macro_expansion_map_p (map))
 120     return;
 121
 122   /* Let's unwind the macros that got expanded and led to the token
 123      which location is WHERE.  We are going to store these macros into
 124      LOC_VEC, so that we can later walk it at our convenience to
 125      display a somewhat meaningful trace of the macro expansion
 126      history to the user.  Note that the first macro of the trace
 127      (which is OPERATE in the example above) is going to be stored at
 128      the beginning of LOC_VEC.  */
 129
 130   do
 131     {
 132       loc.where = where;
 133       loc.map = map;
 134
 135       VEC_safe_push (loc_map_pair, heap, loc_vec, &loc);
 136
 137       /* WHERE is the location of a token inside the expansion of a
 138          macro.  MAP is the map holding the locations of that macro
 139          expansion.  Let's get the location of the token inside the
 140          context that triggered the expansion of this macro.
 141          This is basically how we go "down" in the trace of macro
 142          expansions that led to WHERE.  */
 143       where = linemap_unwind_toward_expansion (line_table, where, &map);
 144     } while (linemap_macro_expansion_map_p (map));
 145
 146   if (first_exp_point_map)
 147     *first_exp_point_map = map;
 148
 149   /* Walk LOC_VEC and print the macro expansion trace, unless the
 150      first macro which expansion triggered this trace was expanded
 151      inside a system header.  */
 152   if (!LINEMAP_SYSP (map))
 153     FOR_EACH_VEC_ELT (loc_map_pair, loc_vec, ix, iter)
 154       {
 155         source_location resolved_def_loc = 0, resolved_exp_loc = 0;
 156         diagnostic_t saved_kind;
 157         const char *saved_prefix;
 158         source_location saved_location;
 159
 160         /* Okay, now here is what we want.  For each token resulting
 161            from macro expansion we want to show: 1/ where in the
 162            definition of the macro the token comes from; 2/ where the
 163            macro got expanded.  */
 164
 165         /* Resolve the location iter->where into the locus 1/ of the
 166            comment above.  */
 167         resolved_def_loc =
 168           linemap_resolve_location (line_table, iter->where,
 169                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 170
 171         /* Resolve the location of the expansion point of the macro
 172            which expansion gave the token represented by def_loc.
 173            This is the locus 2/ of the earlier comment.  */
 174         resolved_exp_loc =
 175           linemap_resolve_location (line_table,
 176                                     MACRO_MAP_EXPANSION_POINT_LOCATION (iter->map),
 177                                     LRK_MACRO_DEFINITION_LOCATION, NULL);
 178
 179         saved_kind = diagnostic->kind;
 180         saved_prefix = context->printer->prefix;
 181         saved_location = diagnostic->location;
 182
 183         diagnostic->kind = DK_NOTE;
 184         diagnostic->location = resolved_def_loc;
 185         pp_base_set_prefix (context->printer,
 186                             diagnostic_build_prefix (context,
 187                                                      diagnostic));
 188         pp_newline (context->printer);
 189         pp_printf (context->printer, "in expansion of macro '%s'",
 190                    linemap_map_get_macro_name (iter->map));
 191         pp_destroy_prefix (context->printer);
 192
 193         diagnostic->location = resolved_exp_loc;
 194         pp_base_set_prefix (context->printer,
 195                             diagnostic_build_prefix (context,
 196                                                      diagnostic));
 197         pp_newline (context->printer);
 198         pp_printf (context->printer, "expanded from here");
 199         pp_destroy_prefix (context->printer);
 200
 201         diagnostic->kind = saved_kind;
 202         diagnostic->location = saved_location;
 203         context->printer->prefix = saved_prefix;
 204       }
 205
 206   VEC_free (loc_map_pair, heap, loc_vec);
 207 }
 208
 209 /*  This is a diagnostic finalizer implementation that is aware of
 210     virtual locations produced by libcpp.
 211
 212     It has to be called by the diagnostic finalizer of front ends that
 213     uses libcpp and wish to get diagnostics involving tokens resulting
 214     from macro expansion.
 215
 216     For a given location, if said location belongs to a token
 217     resulting from a macro expansion, this starter prints the context
 218     of the token.  E.g, for multiply nested macro expansion, it
 219     unwinds the nested macro expansions and prints them in a manner
 220     that is similar to what is done for function call stacks, or
 221     template instantiation contexts.  */
 222 void
 223 virt_loc_aware_diagnostic_finalizer (diagnostic_context *context,
 224                                      diagnostic_info *diagnostic)
 225 {
 226   maybe_unwind_expanded_macro_loc (context, diagnostic,
 227                                    diagnostic->location,
 228                                    NULL);
 229 }