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-2018 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 36 diagnostic_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 44 static void 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 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 99 static void 100 maybe_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. */ 237 void 238 virt_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. */ 246 bool 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 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. */ 309 void 310 tree_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