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