1 /* JSON output for diagnostics 2 Copyright (C) 2018-2020 Free Software Foundation, Inc. 3 Contributed by David Malcolm <dmalcolm@redhat.com>. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "diagnostic.h" 26 #include "diagnostic-metadata.h" 27 #include "json.h" 28 #include "selftest.h" 29 30 /* The top-level JSON array of pending diagnostics. */ 31 32 static json::array *toplevel_array; 33 34 /* The JSON object for the current diagnostic group. */ 35 36 static json::object *cur_group; 37 38 /* The JSON array for the "children" array within the current diagnostic 39 group. */ 40 41 static json::array *cur_children_array; 42 43 /* Generate a JSON object for LOC. */ 44 45 json::value * 46 json_from_expanded_location (location_t loc) 47 { 48 expanded_location exploc = expand_location (loc); 49 json::object *result = new json::object (); 50 if (exploc.file) 51 result->set ("file", new json::string (exploc.file)); 52 result->set ("line", new json::integer_number (exploc.line)); 53 result->set ("column", new json::integer_number (exploc.column)); 54 return result; 55 } 56 57 /* Generate a JSON object for LOC_RANGE. */ 58 59 static json::object * 60 json_from_location_range (const location_range *loc_range, unsigned range_idx) 61 { 62 location_t caret_loc = get_pure_location (loc_range->m_loc); 63 64 if (caret_loc == UNKNOWN_LOCATION) 65 return NULL; 66 67 location_t start_loc = get_start (loc_range->m_loc); 68 location_t finish_loc = get_finish (loc_range->m_loc); 69 70 json::object *result = new json::object (); 71 result->set ("caret", json_from_expanded_location (caret_loc)); 72 if (start_loc != caret_loc 73 && start_loc != UNKNOWN_LOCATION) 74 result->set ("start", json_from_expanded_location (start_loc)); 75 if (finish_loc != caret_loc 76 && finish_loc != UNKNOWN_LOCATION) 77 result->set ("finish", json_from_expanded_location (finish_loc)); 78 79 if (loc_range->m_label) 80 { 81 label_text text; 82 text = loc_range->m_label->get_text (range_idx); 83 if (text.m_buffer) 84 result->set ("label", new json::string (text.m_buffer)); 85 text.maybe_free (); 86 } 87 88 return result; 89 } 90 91 /* Generate a JSON object for HINT. */ 92 93 static json::object * 94 json_from_fixit_hint (const fixit_hint *hint) 95 { 96 json::object *fixit_obj = new json::object (); 97 98 location_t start_loc = hint->get_start_loc (); 99 fixit_obj->set ("start", json_from_expanded_location (start_loc)); 100 location_t next_loc = hint->get_next_loc (); 101 fixit_obj->set ("next", json_from_expanded_location (next_loc)); 102 fixit_obj->set ("string", new json::string (hint->get_string ())); 103 104 return fixit_obj; 105 } 106 107 /* Generate a JSON object for METADATA. */ 108 109 static json::object * 110 json_from_metadata (const diagnostic_metadata *metadata) 111 { 112 json::object *metadata_obj = new json::object (); 113 114 if (metadata->get_cwe ()) 115 metadata_obj->set ("cwe", 116 new json::integer_number (metadata->get_cwe ())); 117 118 return metadata_obj; 119 } 120 121 /* No-op implementation of "begin_diagnostic" for JSON output. */ 122 123 static void 124 json_begin_diagnostic (diagnostic_context *, diagnostic_info *) 125 { 126 } 127 128 /* Implementation of "end_diagnostic" for JSON output. 129 Generate a JSON object for DIAGNOSTIC, and store for output 130 within current diagnostic group. */ 131 132 static void 133 json_end_diagnostic (diagnostic_context *context, diagnostic_info *diagnostic, 134 diagnostic_t orig_diag_kind) 135 { 136 json::object *diag_obj = new json::object (); 137 138 /* Get "kind" of diagnostic. */ 139 { 140 static const char *const diagnostic_kind_text[] = { 141 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T), 142 #include "diagnostic.def" 143 #undef DEFINE_DIAGNOSTIC_KIND 144 "must-not-happen" 145 }; 146 /* Lose the trailing ": ". */ 147 const char *kind_text = diagnostic_kind_text[diagnostic->kind]; 148 size_t len = strlen (kind_text); 149 gcc_assert (len > 2); 150 gcc_assert (kind_text[len - 2] == ':'); 151 gcc_assert (kind_text[len - 1] == ' '); 152 char *rstrip = xstrdup (kind_text); 153 rstrip[len - 2] = '\0'; 154 diag_obj->set ("kind", new json::string (rstrip)); 155 free (rstrip); 156 } 157 158 // FIXME: encoding of the message (json::string requires UTF-8) 159 diag_obj->set ("message", 160 new json::string (pp_formatted_text (context->printer))); 161 pp_clear_output_area (context->printer); 162 163 char *option_text; 164 option_text = context->option_name (context, diagnostic->option_index, 165 orig_diag_kind, diagnostic->kind); 166 if (option_text) 167 { 168 diag_obj->set ("option", new json::string (option_text)); 169 free (option_text); 170 } 171 172 if (context->get_option_url) 173 { 174 char *option_url = context->get_option_url (context, 175 diagnostic->option_index); 176 if (option_url) 177 { 178 diag_obj->set ("option_url", new json::string (option_url)); 179 free (option_url); 180 } 181 } 182 183 /* If we've already emitted a diagnostic within this auto_diagnostic_group, 184 then add diag_obj to its "children" array. */ 185 if (cur_group) 186 { 187 gcc_assert (cur_children_array); 188 cur_children_array->append (diag_obj); 189 } 190 else 191 { 192 /* Otherwise, make diag_obj be the top-level object within the group; 193 add a "children" array. */ 194 toplevel_array->append (diag_obj); 195 cur_group = diag_obj; 196 cur_children_array = new json::array (); 197 diag_obj->set ("children", cur_children_array); 198 } 199 200 const rich_location *richloc = diagnostic->richloc; 201 202 json::array *loc_array = new json::array (); 203 diag_obj->set ("locations", loc_array); 204 205 for (unsigned int i = 0; i < richloc->get_num_locations (); i++) 206 { 207 const location_range *loc_range = richloc->get_range (i); 208 json::object *loc_obj = json_from_location_range (loc_range, i); 209 if (loc_obj) 210 loc_array->append (loc_obj); 211 } 212 213 if (richloc->get_num_fixit_hints ()) 214 { 215 json::array *fixit_array = new json::array (); 216 diag_obj->set ("fixits", fixit_array); 217 for (unsigned int i = 0; i < richloc->get_num_fixit_hints (); i++) 218 { 219 const fixit_hint *hint = richloc->get_fixit_hint (i); 220 json::object *fixit_obj = json_from_fixit_hint (hint); 221 fixit_array->append (fixit_obj); 222 } 223 } 224 225 /* TODO: tree-ish things: 226 TODO: functions 227 TODO: inlining information 228 TODO: macro expansion information. */ 229 230 if (diagnostic->metadata) 231 { 232 json::object *metadata_obj = json_from_metadata (diagnostic->metadata); 233 diag_obj->set ("metadata", metadata_obj); 234 } 235 236 const diagnostic_path *path = richloc->get_path (); 237 if (path && context->make_json_for_path) 238 { 239 json::value *path_value = context->make_json_for_path (context, path); 240 diag_obj->set ("path", path_value); 241 } 242 } 243 244 /* No-op implementation of "begin_group_cb" for JSON output. */ 245 246 static void 247 json_begin_group (diagnostic_context *) 248 { 249 } 250 251 /* Implementation of "end_group_cb" for JSON output. */ 252 253 static void 254 json_end_group (diagnostic_context *) 255 { 256 cur_group = NULL; 257 cur_children_array = NULL; 258 } 259 260 /* Callback for final cleanup for JSON output. */ 261 262 static void 263 json_final_cb (diagnostic_context *) 264 { 265 /* Flush the top-level array. */ 266 toplevel_array->dump (stderr); 267 fprintf (stderr, "\n"); 268 delete toplevel_array; 269 toplevel_array = NULL; 270 } 271 272 /* Set the output format for CONTEXT to FORMAT. */ 273 274 void 275 diagnostic_output_format_init (diagnostic_context *context, 276 enum diagnostics_output_format format) 277 { 278 switch (format) 279 { 280 default: 281 gcc_unreachable (); 282 case DIAGNOSTICS_OUTPUT_FORMAT_TEXT: 283 /* The default; do nothing. */ 284 break; 285 286 case DIAGNOSTICS_OUTPUT_FORMAT_JSON: 287 { 288 /* Set up top-level JSON array. */ 289 if (toplevel_array == NULL) 290 toplevel_array = new json::array (); 291 292 /* Override callbacks. */ 293 context->begin_diagnostic = json_begin_diagnostic; 294 context->end_diagnostic = json_end_diagnostic; 295 context->begin_group_cb = json_begin_group; 296 context->end_group_cb = json_end_group; 297 context->final_cb = json_final_cb; 298 context->print_path = NULL; /* handled in json_end_diagnostic. */ 299 300 /* The metadata is handled in JSON format, rather than as text. */ 301 context->show_cwe = false; 302 303 /* The option is handled in JSON format, rather than as text. */ 304 context->show_option_requested = false; 305 306 /* Don't colorize the text. */ 307 pp_show_color (context->printer) = false; 308 } 309 break; 310 } 311 } 312 313 #if CHECKING_P 314 315 namespace selftest { 316 317 /* We shouldn't call json_from_expanded_location on UNKNOWN_LOCATION, 318 but verify that we handle this gracefully. */ 319 320 static void 321 test_unknown_location () 322 { 323 delete json_from_expanded_location (UNKNOWN_LOCATION); 324 } 325 326 /* Verify that we gracefully handle attempts to serialize bad 327 compound locations. */ 328 329 static void 330 test_bad_endpoints () 331 { 332 location_t bad_endpoints 333 = make_location (BUILTINS_LOCATION, 334 UNKNOWN_LOCATION, UNKNOWN_LOCATION); 335 336 location_range loc_range; 337 loc_range.m_loc = bad_endpoints; 338 loc_range.m_range_display_kind = SHOW_RANGE_WITH_CARET; 339 loc_range.m_label = NULL; 340 341 json::object *obj = json_from_location_range (&loc_range, 0); 342 /* We should have a "caret" value, but no "start" or "finish" values. */ 343 ASSERT_TRUE (obj != NULL); 344 ASSERT_TRUE (obj->get ("caret") != NULL); 345 ASSERT_TRUE (obj->get ("start") == NULL); 346 ASSERT_TRUE (obj->get ("finish") == NULL); 347 delete obj; 348 } 349 350 /* Run all of the selftests within this file. */ 351 352 void 353 diagnostic_format_json_cc_tests () 354 { 355 test_unknown_location (); 356 test_bad_endpoints (); 357 } 358 359 } // namespace selftest 360 361 #endif /* #if CHECKING_P */ 362