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