LCOV - code coverage report
Current view: top level - gcc - diagnostic.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 13 13 100.0 %
Date: 2020-03-28 11:57:23 Functions: 0 0 -
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Various declarations for language-independent diagnostics subroutines.
       2                 :            :    Copyright (C) 2000-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Gabriel Dos Reis <gdr@codesourcery.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                 :            : #ifndef GCC_DIAGNOSTIC_H
      22                 :            : #define GCC_DIAGNOSTIC_H
      23                 :            : 
      24                 :            : #include "pretty-print.h"
      25                 :            : #include "diagnostic-core.h"
      26                 :            : 
      27                 :            : /* Enum for overriding the standard output format.  */
      28                 :            : 
      29                 :            : enum diagnostics_output_format
      30                 :            : {
      31                 :            :   /* The default: textual output.  */
      32                 :            :   DIAGNOSTICS_OUTPUT_FORMAT_TEXT,
      33                 :            : 
      34                 :            :   /* JSON-based output.  */
      35                 :            :   DIAGNOSTICS_OUTPUT_FORMAT_JSON
      36                 :            : };
      37                 :            : 
      38                 :            : /* An enum for controlling how diagnostic_paths should be printed.  */
      39                 :            : enum diagnostic_path_format
      40                 :            : {
      41                 :            :   /* Don't print diagnostic_paths.  */
      42                 :            :   DPF_NONE,
      43                 :            : 
      44                 :            :   /* Print diagnostic_paths by emitting a separate "note" for every event
      45                 :            :      in the path.  */
      46                 :            :   DPF_SEPARATE_EVENTS,
      47                 :            : 
      48                 :            :   /* Print diagnostic_paths by consolidating events together where they
      49                 :            :      are close enough, and printing such runs of events with multiple
      50                 :            :      calls to diagnostic_show_locus, showing the individual events in
      51                 :            :      each run via labels in the source.  */
      52                 :            :   DPF_INLINE_EVENTS
      53                 :            : };
      54                 :            : 
      55                 :            : /* A diagnostic is described by the MESSAGE to send, the FILE and LINE of
      56                 :            :    its context and its KIND (ice, error, warning, note, ...)  See complete
      57                 :            :    list in diagnostic.def.  */
      58                 :            : struct diagnostic_info
      59                 :            : {
      60                 :            :   /* Text to be formatted.  */
      61                 :            :   text_info message;
      62                 :            : 
      63                 :            :   /* The location at which the diagnostic is to be reported.  */
      64                 :            :   rich_location *richloc;
      65                 :            : 
      66                 :            :   /* An optional bundle of metadata associated with the diagnostic
      67                 :            :      (or NULL).  */
      68                 :            :   const diagnostic_metadata *metadata;
      69                 :            : 
      70                 :            :   /* Auxiliary data for client.  */
      71                 :            :   void *x_data;
      72                 :            :   /* The kind of diagnostic it is about.  */
      73                 :            :   diagnostic_t kind;
      74                 :            :   /* Which OPT_* directly controls this diagnostic.  */
      75                 :            :   int option_index;
      76                 :            : };
      77                 :            : 
      78                 :            : /* Each time a diagnostic's classification is changed with a pragma,
      79                 :            :    we record the change and the location of the change in an array of
      80                 :            :    these structs.  */
      81                 :            : struct diagnostic_classification_change_t
      82                 :            : {
      83                 :            :   location_t location;
      84                 :            :   int option;
      85                 :            :   diagnostic_t kind;
      86                 :            : };
      87                 :            : 
      88                 :            : /*  Forward declarations.  */
      89                 :            : typedef void (*diagnostic_starter_fn) (diagnostic_context *,
      90                 :            :                                        diagnostic_info *);
      91                 :            : 
      92                 :            : typedef void (*diagnostic_start_span_fn) (diagnostic_context *,
      93                 :            :                                           expanded_location);
      94                 :            : 
      95                 :            : typedef void (*diagnostic_finalizer_fn) (diagnostic_context *,
      96                 :            :                                          diagnostic_info *,
      97                 :            :                                          diagnostic_t);
      98                 :            : 
      99                 :            : class edit_context;
     100                 :            : namespace json { class value; }
     101                 :            : 
     102                 :            : /* This data structure bundles altogether any information relevant to
     103                 :            :    the context of a diagnostic message.  */
     104                 :            : struct diagnostic_context
     105                 :            : {
     106                 :            :   /* Where most of the diagnostic formatting work is done.  */
     107                 :            :   pretty_printer *printer;
     108                 :            : 
     109                 :            :   /* The number of times we have issued diagnostics.  */
     110                 :            :   int diagnostic_count[DK_LAST_DIAGNOSTIC_KIND];
     111                 :            : 
     112                 :            :   /* True if it has been requested that warnings be treated as errors.  */
     113                 :            :   bool warning_as_error_requested;
     114                 :            : 
     115                 :            :   /* The number of option indexes that can be passed to warning() et
     116                 :            :      al.  */
     117                 :            :   int n_opts;
     118                 :            : 
     119                 :            :   /* For each option index that can be passed to warning() et al
     120                 :            :      (OPT_* from options.h when using this code with the core GCC
     121                 :            :      options), this array may contain a new kind that the diagnostic
     122                 :            :      should be changed to before reporting, or DK_UNSPECIFIED to leave
     123                 :            :      it as the reported kind, or DK_IGNORED to not report it at
     124                 :            :      all.  */
     125                 :            :   diagnostic_t *classify_diagnostic;
     126                 :            : 
     127                 :            :   /* History of all changes to the classifications above.  This list
     128                 :            :      is stored in location-order, so we can search it, either
     129                 :            :      binary-wise or end-to-front, to find the most recent
     130                 :            :      classification for a given diagnostic, given the location of the
     131                 :            :      diagnostic.  */
     132                 :            :   diagnostic_classification_change_t *classification_history;
     133                 :            : 
     134                 :            :   /* The size of the above array.  */
     135                 :            :   int n_classification_history;
     136                 :            : 
     137                 :            :   /* For pragma push/pop.  */
     138                 :            :   int *push_list;
     139                 :            :   int n_push;
     140                 :            : 
     141                 :            :   /* True if we should print the source line with a caret indicating
     142                 :            :      the location.  */
     143                 :            :   bool show_caret;
     144                 :            : 
     145                 :            :   /* Maximum width of the source line printed.  */
     146                 :            :   int caret_max_width;
     147                 :            : 
     148                 :            :   /* Character used for caret diagnostics.  */
     149                 :            :   char caret_chars[rich_location::STATICALLY_ALLOCATED_RANGES];
     150                 :            : 
     151                 :            :   /* True if we should print any CWE identifiers associated with
     152                 :            :      diagnostics.  */
     153                 :            :   bool show_cwe;
     154                 :            : 
     155                 :            :   /* How should diagnostic_path objects be printed.  */
     156                 :            :   enum diagnostic_path_format path_format;
     157                 :            : 
     158                 :            :   /* True if we should print stack depths when printing diagnostic paths.  */
     159                 :            :   bool show_path_depths;
     160                 :            : 
     161                 :            :   /* True if we should print the command line option which controls
     162                 :            :      each diagnostic, if known.  */
     163                 :            :   bool show_option_requested;
     164                 :            : 
     165                 :            :   /* True if we should raise a SIGABRT on errors.  */
     166                 :            :   bool abort_on_error;
     167                 :            : 
     168                 :            :   /* True if we should show the column number on diagnostics.  */
     169                 :            :   bool show_column;
     170                 :            : 
     171                 :            :   /* True if pedwarns are errors.  */
     172                 :            :   bool pedantic_errors;
     173                 :            : 
     174                 :            :   /* True if permerrors are warnings.  */
     175                 :            :   bool permissive;
     176                 :            : 
     177                 :            :   /* The index of the option to associate with turning permerrors into
     178                 :            :      warnings.  */
     179                 :            :   int opt_permissive;
     180                 :            : 
     181                 :            :   /* True if errors are fatal.  */
     182                 :            :   bool fatal_errors;
     183                 :            : 
     184                 :            :   /* True if all warnings should be disabled.  */
     185                 :            :   bool dc_inhibit_warnings;
     186                 :            : 
     187                 :            :   /* True if warnings should be given in system headers.  */
     188                 :            :   bool dc_warn_system_headers;
     189                 :            : 
     190                 :            :   /* Maximum number of errors to report.  */
     191                 :            :   int max_errors;
     192                 :            : 
     193                 :            :   /* This function is called before any message is printed out.  It is
     194                 :            :      responsible for preparing message prefix and such.  For example, it
     195                 :            :      might say:
     196                 :            :      In file included from "/usr/local/include/curses.h:5:
     197                 :            :                       from "/home/gdr/src/nifty_printer.h:56:
     198                 :            :                       ...
     199                 :            :   */
     200                 :            :   diagnostic_starter_fn begin_diagnostic;
     201                 :            : 
     202                 :            :   /* This function is called by diagnostic_show_locus in between
     203                 :            :      disjoint spans of source code, so that the context can print
     204                 :            :      something to indicate that a new span of source code has begun.  */
     205                 :            :   diagnostic_start_span_fn start_span;
     206                 :            : 
     207                 :            :   /* This function is called after the diagnostic message is printed.  */
     208                 :            :   diagnostic_finalizer_fn end_diagnostic;
     209                 :            : 
     210                 :            :   /* Client hook to report an internal error.  */
     211                 :            :   void (*internal_error) (diagnostic_context *, const char *, va_list *);
     212                 :            : 
     213                 :            :   /* Client hook to say whether the option controlling a diagnostic is
     214                 :            :      enabled.  Returns nonzero if enabled, zero if disabled.  */
     215                 :            :   int (*option_enabled) (int, unsigned, void *);
     216                 :            : 
     217                 :            :   /* Client information to pass as second argument to
     218                 :            :      option_enabled.  */
     219                 :            :   void *option_state;
     220                 :            : 
     221                 :            :   /* Client hook to return the name of an option that controls a
     222                 :            :      diagnostic.  Returns malloced memory.  The first diagnostic_t
     223                 :            :      argument is the kind of diagnostic before any reclassification
     224                 :            :      (of warnings as errors, etc.); the second is the kind after any
     225                 :            :      reclassification.  May return NULL if no name is to be printed.
     226                 :            :      May be passed 0 as well as the index of a particular option.  */
     227                 :            :   char *(*option_name) (diagnostic_context *, int, diagnostic_t, diagnostic_t);
     228                 :            : 
     229                 :            :   /* Client hook to return a URL describing the option that controls
     230                 :            :      a diagnostic.  Returns malloced memory.  May return NULL if no URL
     231                 :            :      is available.  May be passed 0 as well as the index of a
     232                 :            :      particular option.  */
     233                 :            :   char *(*get_option_url) (diagnostic_context *, int);
     234                 :            : 
     235                 :            :   void (*print_path) (diagnostic_context *, const diagnostic_path *);
     236                 :            :   json::value *(*make_json_for_path) (diagnostic_context *, const diagnostic_path *);
     237                 :            : 
     238                 :            :   /* Auxiliary data for client.  */
     239                 :            :   void *x_data;
     240                 :            : 
     241                 :            :   /* Used to detect that the last caret was printed at the same location.  */
     242                 :            :   location_t last_location;
     243                 :            : 
     244                 :            :   /* Used to detect when the input file stack has changed since last
     245                 :            :      described.  */
     246                 :            :   const line_map_ordinary *last_module;
     247                 :            : 
     248                 :            :   int lock;
     249                 :            : 
     250                 :            :   /* A copy of lang_hooks.option_lang_mask ().  */
     251                 :            :   unsigned lang_mask;
     252                 :            : 
     253                 :            :   bool inhibit_notes_p;
     254                 :            : 
     255                 :            :   /* When printing source code, should the characters at carets and ranges
     256                 :            :      be colorized? (assuming colorization is on at all).
     257                 :            :      This should be true for frontends that generate range information
     258                 :            :      (so that the ranges of code are colorized),
     259                 :            :      and false for frontends that merely specify points within the
     260                 :            :      source code (to avoid e.g. colorizing just the first character in
     261                 :            :      a token, which would look strange).  */
     262                 :            :   bool colorize_source_p;
     263                 :            : 
     264                 :            :   /* When printing source code, should labelled ranges be printed?  */
     265                 :            :   bool show_labels_p;
     266                 :            : 
     267                 :            :   /* When printing source code, should there be a left-hand margin
     268                 :            :      showing line numbers?  */
     269                 :            :   bool show_line_numbers_p;
     270                 :            : 
     271                 :            :   /* If printing source code, what should the minimum width of the margin
     272                 :            :      be?  Line numbers will be right-aligned, and padded to this width.  */
     273                 :            :   int min_margin_width;
     274                 :            : 
     275                 :            :   /* Usable by plugins; if true, print a debugging ruler above the
     276                 :            :      source output.  */
     277                 :            :   bool show_ruler_p;
     278                 :            : 
     279                 :            :   /* If true, print fixits in machine-parseable form after the
     280                 :            :      rest of the diagnostic.  */
     281                 :            :   bool parseable_fixits_p;
     282                 :            : 
     283                 :            :   /* If non-NULL, an edit_context to which fix-it hints should be
     284                 :            :      applied, for generating patches.  */
     285                 :            :   edit_context *edit_context_ptr;
     286                 :            : 
     287                 :            :   /* How many diagnostic_group instances are currently alive.  */
     288                 :            :   int diagnostic_group_nesting_depth;
     289                 :            : 
     290                 :            :   /* How many diagnostics have been emitted since the bottommost
     291                 :            :      diagnostic_group was pushed.  */
     292                 :            :   int diagnostic_group_emission_count;
     293                 :            : 
     294                 :            :   /* Optional callbacks for handling diagnostic groups.  */
     295                 :            : 
     296                 :            :   /* If non-NULL, this will be called immediately before the first
     297                 :            :      time a diagnostic is emitted within a stack of groups.  */
     298                 :            :   void (*begin_group_cb) (diagnostic_context * context);
     299                 :            : 
     300                 :            :   /* If non-NULL, this will be called when a stack of groups is
     301                 :            :      popped if any diagnostics were emitted within that group.  */
     302                 :            :   void (*end_group_cb) (diagnostic_context * context);
     303                 :            : 
     304                 :            :   /* Callback for final cleanup.  */
     305                 :            :   void (*final_cb) (diagnostic_context *context);
     306                 :            : };
     307                 :            : 
     308                 :            : static inline void
     309                 :        795 : diagnostic_inhibit_notes (diagnostic_context * context)
     310                 :            : {
     311                 :        795 :   context->inhibit_notes_p = true;
     312                 :        795 : }
     313                 :            : 
     314                 :            : 
     315                 :            : /* Client supplied function to announce a diagnostic.  */
     316                 :            : #define diagnostic_starter(DC) (DC)->begin_diagnostic
     317                 :            : 
     318                 :            : /* Client supplied function called after a diagnostic message is
     319                 :            :    displayed.  */
     320                 :            : #define diagnostic_finalizer(DC) (DC)->end_diagnostic
     321                 :            : 
     322                 :            : /* Extension hooks for client.  */
     323                 :            : #define diagnostic_context_auxiliary_data(DC) (DC)->x_data
     324                 :            : #define diagnostic_info_auxiliary_data(DI) (DI)->x_data
     325                 :            : 
     326                 :            : /* Same as pp_format_decoder.  Works on 'diagnostic_context *'.  */
     327                 :            : #define diagnostic_format_decoder(DC) ((DC)->printer->format_decoder)
     328                 :            : 
     329                 :            : /* Same as output_prefixing_rule.  Works on 'diagnostic_context *'.  */
     330                 :            : #define diagnostic_prefixing_rule(DC) ((DC)->printer->wrapping.rule)
     331                 :            : 
     332                 :            : /* Raise SIGABRT on any diagnostic of severity DK_ERROR or higher.  */
     333                 :            : #define diagnostic_abort_on_error(DC) \
     334                 :            :   (DC)->abort_on_error = true
     335                 :            : 
     336                 :            : /* This diagnostic_context is used by front-ends that directly output
     337                 :            :    diagnostic messages without going through `error', `warning',
     338                 :            :    and similar functions.  */
     339                 :            : extern diagnostic_context *global_dc;
     340                 :            : 
     341                 :            : /* Returns whether the diagnostic framework has been intialized already and is
     342                 :            :    ready for use.  */
     343                 :            : #define diagnostic_ready_p() (global_dc->printer != NULL)
     344                 :            : 
     345                 :            : /* The total count of a KIND of diagnostics emitted so far.  */
     346                 :            : #define diagnostic_kind_count(DC, DK) (DC)->diagnostic_count[(int) (DK)]
     347                 :            : 
     348                 :            : /* The number of errors that have been issued so far.  Ideally, these
     349                 :            :    would take a diagnostic_context as an argument.  */
     350                 :            : #define errorcount diagnostic_kind_count (global_dc, DK_ERROR)
     351                 :            : /* Similarly, but for warnings.  */
     352                 :            : #define warningcount diagnostic_kind_count (global_dc, DK_WARNING)
     353                 :            : /* Similarly, but for warnings promoted to errors.  */
     354                 :            : #define werrorcount diagnostic_kind_count (global_dc, DK_WERROR)
     355                 :            : /* Similarly, but for sorrys.  */
     356                 :            : #define sorrycount diagnostic_kind_count (global_dc, DK_SORRY)
     357                 :            : 
     358                 :            : /* Returns nonzero if warnings should be emitted.  */
     359                 :            : #define diagnostic_report_warnings_p(DC, LOC)                           \
     360                 :            :   (!(DC)->dc_inhibit_warnings                                                \
     361                 :            :    && !(in_system_header_at (LOC) && !(DC)->dc_warn_system_headers))
     362                 :            : 
     363                 :            : /* Override the option index to be used for reporting a
     364                 :            :    diagnostic.  */
     365                 :            : 
     366                 :            : static inline void
     367                 :       7390 : diagnostic_override_option_index (diagnostic_info *info, int optidx)
     368                 :            : {
     369                 :       7390 :   info->option_index = optidx;
     370                 :          6 : }
     371                 :            : 
     372                 :            : /* Diagnostic related functions.  */
     373                 :            : extern void diagnostic_initialize (diagnostic_context *, int);
     374                 :            : extern void diagnostic_color_init (diagnostic_context *, int value = -1);
     375                 :            : extern void diagnostic_urls_init (diagnostic_context *, int value = -1);
     376                 :            : extern void diagnostic_finish (diagnostic_context *);
     377                 :            : extern void diagnostic_report_current_module (diagnostic_context *, location_t);
     378                 :            : extern void diagnostic_show_locus (diagnostic_context *,
     379                 :            :                                    rich_location *richloc,
     380                 :            :                                    diagnostic_t diagnostic_kind);
     381                 :            : extern void diagnostic_show_any_path (diagnostic_context *, diagnostic_info *);
     382                 :            : 
     383                 :            : /* Force diagnostics controlled by OPTIDX to be kind KIND.  */
     384                 :            : extern diagnostic_t diagnostic_classify_diagnostic (diagnostic_context *,
     385                 :            :                                                     int /* optidx */,
     386                 :            :                                                     diagnostic_t /* kind */,
     387                 :            :                                                     location_t);
     388                 :            : extern void diagnostic_push_diagnostics (diagnostic_context *, location_t);
     389                 :            : extern void diagnostic_pop_diagnostics (diagnostic_context *, location_t);
     390                 :            : extern bool diagnostic_report_diagnostic (diagnostic_context *,
     391                 :            :                                           diagnostic_info *);
     392                 :            : #ifdef ATTRIBUTE_GCC_DIAG
     393                 :            : extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *,
     394                 :            :                                  rich_location *, diagnostic_t) ATTRIBUTE_GCC_DIAG(2,0);
     395                 :            : extern void diagnostic_set_info_translated (diagnostic_info *, const char *,
     396                 :            :                                             va_list *, rich_location *,
     397                 :            :                                             diagnostic_t)
     398                 :            :      ATTRIBUTE_GCC_DIAG(2,0);
     399                 :            : extern void diagnostic_append_note (diagnostic_context *, location_t,
     400                 :            :                                     const char *, ...) ATTRIBUTE_GCC_DIAG(3,4);
     401                 :            : #endif
     402                 :            : extern char *diagnostic_build_prefix (diagnostic_context *, const diagnostic_info *);
     403                 :            : void default_diagnostic_starter (diagnostic_context *, diagnostic_info *);
     404                 :            : void default_diagnostic_start_span_fn (diagnostic_context *,
     405                 :            :                                        expanded_location);
     406                 :            : void default_diagnostic_finalizer (diagnostic_context *, diagnostic_info *,
     407                 :            :                                    diagnostic_t);
     408                 :            : void diagnostic_set_caret_max_width (diagnostic_context *context, int value);
     409                 :            : void diagnostic_action_after_output (diagnostic_context *, diagnostic_t);
     410                 :            : void diagnostic_check_max_errors (diagnostic_context *, bool flush = false);
     411                 :            : 
     412                 :            : void diagnostic_file_cache_fini (void);
     413                 :            : 
     414                 :            : int get_terminal_width (void);
     415                 :            : 
     416                 :            : /* Return the location associated to this diagnostic. Parameter WHICH
     417                 :            :    specifies which location. By default, expand the first one.  */
     418                 :            : 
     419                 :            : static inline location_t
     420                 :   16430070 : diagnostic_location (const diagnostic_info * diagnostic, int which = 0)
     421                 :            : {
     422                 :   16430070 :   return diagnostic->message.get_location (which);
     423                 :            : }
     424                 :            : 
     425                 :            : /* Return the number of locations to be printed in DIAGNOSTIC.  */
     426                 :            : 
     427                 :            : static inline unsigned int
     428                 :            : diagnostic_num_locations (const diagnostic_info * diagnostic)
     429                 :            : {
     430                 :            :   return diagnostic->message.m_richloc->get_num_locations ();
     431                 :            : }
     432                 :            : 
     433                 :            : /* Expand the location of this diagnostic. Use this function for
     434                 :            :    consistency.  Parameter WHICH specifies which location. By default,
     435                 :            :    expand the first one.  */
     436                 :            : 
     437                 :            : static inline expanded_location
     438                 :    1039108 : diagnostic_expand_location (const diagnostic_info * diagnostic, int which = 0)
     439                 :            : {
     440                 :    1039108 :   return diagnostic->richloc->get_expanded_location (which);
     441                 :            : }
     442                 :            : 
     443                 :            : /* This is somehow the right-side margin of a caret line, that is, we
     444                 :            :    print at least these many characters after the position pointed at
     445                 :            :    by the caret.  */
     446                 :            : const int CARET_LINE_MARGIN = 10;
     447                 :            : 
     448                 :            : /* Return true if the two locations can be represented within the same
     449                 :            :    caret line.  This is used to build a prefix and also to determine
     450                 :            :    whether to print one or two caret lines.  */
     451                 :            : 
     452                 :            : static inline bool
     453                 :        324 : diagnostic_same_line (const diagnostic_context *context,
     454                 :            :                        expanded_location s1, expanded_location s2)
     455                 :            : {
     456                 :        321 :   return s2.column && s1.line == s2.line 
     457                 :        420 :     && context->caret_max_width - CARET_LINE_MARGIN > abs (s1.column - s2.column);
     458                 :            : }
     459                 :            : 
     460                 :            : extern const char *diagnostic_get_color_for_kind (diagnostic_t kind);
     461                 :            : 
     462                 :            : /* Pure text formatting support functions.  */
     463                 :            : extern char *file_name_as_prefix (diagnostic_context *, const char *);
     464                 :            : 
     465                 :            : extern char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
     466                 :            : 
     467                 :            : extern void diagnostic_output_format_init (diagnostic_context *,
     468                 :            :                                            enum diagnostics_output_format);
     469                 :            : 
     470                 :            : /* Compute the number of digits in the decimal representation of an integer.  */
     471                 :            : extern int num_digits (int);
     472                 :            : 
     473                 :            : extern json::value *json_from_expanded_location (location_t loc);
     474                 :            : 
     475                 :            : #endif /* ! GCC_DIAGNOSTIC_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.