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-2022 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 "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. */
35 void
diagnostic_report_current_function(diagnostic_context * context,diagnostic_info * diagnostic)36 diagnostic_report_current_function (diagnostic_context *context,
37 diagnostic_info *diagnostic)
38 {
39 location_t loc = diagnostic_location (diagnostic);
40 diagnostic_report_current_module (context, loc);
41 lang_hooks.print_error_function (context, LOCATION_FILE (loc), diagnostic);
42 }
43
44 static void
default_tree_diagnostic_starter(diagnostic_context * context,diagnostic_info * diagnostic)45 default_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. */
56 struct loc_map_pair
57 {
58 const line_map_macro *map;
59 location_t 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
99 void
maybe_unwind_expanded_macro_loc(diagnostic_context * context,location_t where)100 maybe_unwind_expanded_macro_loc (diagnostic_context *context,
101 location_t where)
102 {
103 const struct line_map *map;
104 auto_vec<loc_map_pair> loc_vec;
105 unsigned ix;
106 loc_map_pair loc, *iter;
107
108 const location_t original_loc = where;
109
110 map = linemap_lookup (line_table, where);
111 if (!linemap_macro_expansion_map_p (map))
112 return;
113
114 /* Let's unwind the macros that got expanded and led to the token
115 which location is WHERE. We are going to store these macros into
116 LOC_VEC, so that we can later walk it at our convenience to
117 display a somewhat meaningful trace of the macro expansion
118 history to the user. Note that the first macro of the trace
119 (which is OPERATE in the example above) is going to be stored at
120 the beginning of LOC_VEC. */
121
122 do
123 {
124 loc.where = where;
125 loc.map = linemap_check_macro (map);
126
127 loc_vec.safe_push (loc);
128
129 /* WHERE is the location of a token inside the expansion of a
130 macro. MAP is the map holding the locations of that macro
131 expansion. Let's get the location of the token inside the
132 context that triggered the expansion of this macro.
133 This is basically how we go "down" in the trace of macro
134 expansions that led to WHERE. */
135 where = linemap_unwind_toward_expansion (line_table, where, &map);
136 } while (linemap_macro_expansion_map_p (map));
137
138 /* Now map is set to the map of the location in the source that
139 first triggered the macro expansion. This must be an ordinary map. */
140 const line_map_ordinary *ord_map = linemap_check_ordinary (map);
141
142 /* Walk LOC_VEC and print the macro expansion trace, unless the
143 first macro which expansion triggered this trace was expanded
144 inside a system header. */
145 int saved_location_line =
146 expand_location_to_spelling_point (original_loc).line;
147
148 if (!LINEMAP_SYSP (ord_map))
149 FOR_EACH_VEC_ELT (loc_vec, ix, iter)
150 {
151 /* Sometimes, in the unwound macro expansion trace, we want to
152 print a part of the context that shows where, in the
153 definition of the relevant macro, is the token (we are
154 looking at) used. That is the case in the introductory
155 comment of this function, where we print:
156
157 test.c:2:9: note: in definition of macro 'OPERATE'.
158
159 We print that "macro definition context" because the
160 diagnostic line (emitted by the call to
161 pp_ouput_formatted_text in diagnostic_report_diagnostic):
162
163 test.c:5:14: error: invalid operands to binary << (have ‘double’ and ‘int’)
164
165 does not point into the definition of the macro where the
166 token '<<' (that is an argument to the function-like macro
167 OPERATE) is used. So we must "display" the line of that
168 macro definition context to the user somehow.
169
170 A contrario, when the first interesting diagnostic line
171 points into the definition of the macro, we don't need to
172 display any line for that macro definition in the trace
173 anymore, otherwise it'd be redundant. */
174
175 /* Okay, now here is what we want. For each token resulting
176 from macro expansion we want to show: 1/ where in the
177 definition of the macro the token comes from; 2/ where the
178 macro got expanded. */
179
180 /* Resolve the location iter->where into the locus 1/ of the
181 comment above. */
182 location_t resolved_def_loc =
183 linemap_resolve_location (line_table, iter->where,
184 LRK_MACRO_DEFINITION_LOCATION, NULL);
185
186 /* Don't print trace for locations that are reserved or from
187 within a system header. */
188 const line_map_ordinary *m = NULL;
189 location_t l =
190 linemap_resolve_location (line_table, resolved_def_loc,
191 LRK_SPELLING_LOCATION, &m);
192 if (l < RESERVED_LOCATION_COUNT || LINEMAP_SYSP (m))
193 continue;
194
195 /* We need to print the context of the macro definition only
196 when the locus of the first displayed diagnostic (displayed
197 before this trace) was inside the definition of the
198 macro. */
199 int resolved_def_loc_line = SOURCE_LINE (m, l);
200 if (ix == 0 && saved_location_line != resolved_def_loc_line)
201 {
202 diagnostic_append_note (context, resolved_def_loc,
203 "in definition of macro %qs",
204 linemap_map_get_macro_name (iter->map));
205 /* At this step, as we've printed the context of the macro
206 definition, we don't want to print the context of its
207 expansion, otherwise, it'd be redundant. */
208 continue;
209 }
210
211 /* Resolve the location of the expansion point of the macro
212 which expansion gave the token represented by def_loc.
213 This is the locus 2/ of the earlier comment. */
214 location_t resolved_exp_loc =
215 linemap_resolve_location (line_table,
216 MACRO_MAP_EXPANSION_POINT_LOCATION (iter->map),
217 LRK_MACRO_DEFINITION_LOCATION, NULL);
218
219 diagnostic_append_note (context, resolved_exp_loc,
220 "in expansion of macro %qs",
221 linemap_map_get_macro_name (iter->map));
222 }
223 }
224
225 /* This is a diagnostic finalizer implementation that is aware of
226 virtual locations produced by libcpp.
227
228 It has to be called by the diagnostic finalizer of front ends that
229 uses libcpp and wish to get diagnostics involving tokens resulting
230 from macro expansion.
231
232 For a given location, if said location belongs to a token
233 resulting from a macro expansion, this starter prints the context
234 of the token. E.g, for multiply nested macro expansion, it
235 unwinds the nested macro expansions and prints them in a manner
236 that is similar to what is done for function call stacks, or
237 template instantiation contexts. */
238 void
virt_loc_aware_diagnostic_finalizer(diagnostic_context * context,diagnostic_info * diagnostic)239 virt_loc_aware_diagnostic_finalizer (diagnostic_context *context,
240 diagnostic_info *diagnostic)
241 {
242 maybe_unwind_expanded_macro_loc (context, diagnostic_location (diagnostic));
243 }
244
245 /* Default tree printer. Handles declarations only. */
246 bool
default_tree_printer(pretty_printer * pp,text_info * text,const char * spec,int precision,bool wide,bool set_locus,bool hash,bool *,const char **)247 default_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 default:
280 return false;
281 }
282
283 if (set_locus)
284 text->set_location (0, DECL_SOURCE_LOCATION (t), SHOW_RANGE_WITH_CARET);
285
286 if (DECL_P (t))
287 {
288 const char *n = DECL_NAME (t)
289 ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
290 : _("<anonymous>");
291 pp_string (pp, n);
292 }
293 else
294 dump_generic_node (pp, t, 0, TDF_SLIM, 0);
295
296 return true;
297 }
298
299 /* Set the locations of call sites along the inlining stack corresponding
300 to the DIAGNOSTIC location. */
301
302 static void
set_inlining_locations(diagnostic_context *,diagnostic_info * diagnostic)303 set_inlining_locations (diagnostic_context *,
304 diagnostic_info *diagnostic)
305 {
306 location_t loc = diagnostic_location (diagnostic);
307 tree block = LOCATION_BLOCK (loc);
308
309 /* Count the number of locations in system headers. When all are,
310 warnings are suppressed by -Wno-system-headers. Otherwise, they
311 involve some user code, possibly inlined into a function in a system
312 header, and are not treated as coming from system headers. */
313 unsigned nsyslocs = 0;
314
315 /* Use a reference to the vector of locations for convenience. */
316 auto &ilocs = diagnostic->m_iinfo.m_ilocs;
317
318 while (block && TREE_CODE (block) == BLOCK
319 && BLOCK_ABSTRACT_ORIGIN (block))
320 {
321 tree ao = BLOCK_ABSTRACT_ORIGIN (block);
322 if (TREE_CODE (ao) == FUNCTION_DECL)
323 {
324 if (!diagnostic->m_iinfo.m_ao)
325 diagnostic->m_iinfo.m_ao = block;
326
327 location_t bsloc = BLOCK_SOURCE_LOCATION (block);
328 ilocs.safe_push (bsloc);
329 if (in_system_header_at (bsloc))
330 ++nsyslocs;
331 }
332 else if (TREE_CODE (ao) != BLOCK)
333 break;
334
335 block = BLOCK_SUPERCONTEXT (block);
336 }
337
338 if (ilocs.length ())
339 {
340 /* When there is an inlining context use the macro expansion
341 location for the original location and bump up NSYSLOCS if
342 it's in a system header since it's not counted above. */
343 location_t sysloc = expansion_point_location_if_in_system_header (loc);
344 if (sysloc != loc)
345 {
346 loc = sysloc;
347 ++nsyslocs;
348 }
349 }
350 else
351 {
352 /* When there's no inlining context use the original location
353 and set NSYSLOCS accordingly. */
354 nsyslocs = in_system_header_at (loc) != 0;
355 }
356
357 ilocs.safe_push (loc);
358
359 /* Set if all locations are in a system header. */
360 diagnostic->m_iinfo.m_allsyslocs = nsyslocs == ilocs.length ();
361
362 if (tree *ao = pp_ti_abstract_origin (&diagnostic->message))
363 *ao = (tree)diagnostic->m_iinfo.m_ao;
364 }
365
366 /* Sets CONTEXT to use language independent diagnostics. */
367 void
tree_diagnostics_defaults(diagnostic_context * context)368 tree_diagnostics_defaults (diagnostic_context *context)
369 {
370 diagnostic_starter (context) = default_tree_diagnostic_starter;
371 diagnostic_finalizer (context) = default_diagnostic_finalizer;
372 diagnostic_format_decoder (context) = default_tree_printer;
373 context->print_path = default_tree_diagnostic_path_printer;
374 context->make_json_for_path = default_tree_make_json_for_path;
375 context->set_locations_cb = set_inlining_locations;
376 }
377