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