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-2013 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 "tree-diagnostic.h" 29 #include "dumpfile.h" /* TDF_DIAGNOSTIC */ 30 #include "langhooks.h" 31 #include "langhooks-def.h" 32 #include "vec.h" 33 #include "intl.h" 34 35 /* Prints out, if necessary, the name of the current function 36 that caused an error. Called from all error and warning functions. */ 37 void 38 diagnostic_report_current_function (diagnostic_context *context, 39 diagnostic_info *diagnostic) 40 { 41 diagnostic_report_current_module (context, diagnostic->location); 42 lang_hooks.print_error_function (context, input_filename, diagnostic); 43 } 44 45 static void 46 default_tree_diagnostic_starter (diagnostic_context *context, 47 diagnostic_info *diagnostic) 48 { 49 diagnostic_report_current_function (context, diagnostic); 50 pp_set_prefix (context->printer, diagnostic_build_prefix (context, 51 diagnostic)); 52 } 53 54 /* This is a pair made of a location and the line map it originated 55 from. It's used in the maybe_unwind_expanded_macro_loc function 56 below. */ 57 typedef struct 58 { 59 const struct line_map *map; 60 source_location where; 61 } loc_map_pair; 62 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 definition of macro 'OPERATE' 92 test.c:8:3: note: in expansion of macro 'SHIFTL' 93 test.c:13:3: note: in expansion of macro 'MULT' 94 95 The part that goes from the third to the fifth line of this 96 diagnostic (the lines containing the 'note:' string) is called the 97 unwound macro expansion trace. That's the part generated by this 98 function. */ 99 100 static void 101 maybe_unwind_expanded_macro_loc (diagnostic_context *context, 102 const diagnostic_info *diagnostic, 103 source_location where) 104 { 105 const struct line_map *map; 106 vec<loc_map_pair> loc_vec = vNULL; 107 unsigned ix; 108 loc_map_pair loc, *iter; 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 = 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 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).line; 146 147 if (!LINEMAP_SYSP (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 struct line_map *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 loc_vec.release (); 224 } 225 226 /* This is a diagnostic finalizer implementation that is aware of 227 virtual locations produced by libcpp. 228 229 It has to be called by the diagnostic finalizer of front ends that 230 uses libcpp and wish to get diagnostics involving tokens resulting 231 from macro expansion. 232 233 For a given location, if said location belongs to a token 234 resulting from a macro expansion, this starter prints the context 235 of the token. E.g, for multiply nested macro expansion, it 236 unwinds the nested macro expansions and prints them in a manner 237 that is similar to what is done for function call stacks, or 238 template instantiation contexts. */ 239 void 240 virt_loc_aware_diagnostic_finalizer (diagnostic_context *context, 241 diagnostic_info *diagnostic) 242 { 243 maybe_unwind_expanded_macro_loc (context, diagnostic, 244 diagnostic->location); 245 } 246 247 /* Default tree printer. Handles declarations only. */ 248 static bool 249 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec, 250 int precision, bool wide, bool set_locus, bool hash) 251 { 252 tree t; 253 254 /* FUTURE: %+x should set the locus. */ 255 if (precision != 0 || wide || hash) 256 return false; 257 258 switch (*spec) 259 { 260 case 'E': 261 t = va_arg (*text->args_ptr, tree); 262 if (TREE_CODE (t) == IDENTIFIER_NODE) 263 { 264 pp_identifier (pp, IDENTIFIER_POINTER (t)); 265 return true; 266 } 267 break; 268 269 case 'D': 270 t = va_arg (*text->args_ptr, tree); 271 if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t)) 272 t = DECL_DEBUG_EXPR (t); 273 break; 274 275 case 'F': 276 case 'T': 277 t = va_arg (*text->args_ptr, tree); 278 break; 279 280 case 'K': 281 percent_K_format (text); 282 return true; 283 284 default: 285 return false; 286 } 287 288 if (set_locus && text->locus) 289 *text->locus = DECL_SOURCE_LOCATION (t); 290 291 if (DECL_P (t)) 292 { 293 const char *n = DECL_NAME (t) 294 ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2)) 295 : _("<anonymous>"); 296 pp_string (pp, n); 297 } 298 else 299 dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0); 300 301 return true; 302 } 303 304 /* Sets CONTEXT to use language independent diagnostics. */ 305 void 306 tree_diagnostics_defaults (diagnostic_context *context) 307 { 308 diagnostic_starter (context) = default_tree_diagnostic_starter; 309 diagnostic_finalizer (context) = default_diagnostic_finalizer; 310 diagnostic_format_decoder (context) = default_tree_printer; 311 } 312