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
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 "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.  */
47void
48diagnostic_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
56static void
57default_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.  */
68typedef 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
111static void
112maybe_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.  */
250void
251virt_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.  */
259static bool
260default_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.  */
316void
317tree_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}
323