LCOV - code coverage report
Current view: top level - gcc/c-family - c-opts.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 735 852 86.3 %
Date: 2020-03-28 11:57:23 Functions: 29 33 87.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* C/ObjC/C++ command line option handling.
       2                 :            :    Copyright (C) 2002-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Neil Booth.
       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                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "tm.h"
      25                 :            : #include "c-target.h"
      26                 :            : #include "c-common.h"
      27                 :            : #include "memmodel.h"
      28                 :            : #include "tm_p.h"             /* For C_COMMON_OVERRIDE_OPTIONS.  */
      29                 :            : #include "diagnostic.h"
      30                 :            : #include "c-pragma.h"
      31                 :            : #include "flags.h"
      32                 :            : #include "toplev.h"
      33                 :            : #include "langhooks.h"
      34                 :            : #include "tree-diagnostic.h" /* for virt_loc_aware_diagnostic_finalizer */
      35                 :            : #include "intl.h"
      36                 :            : #include "cppdefault.h"
      37                 :            : #include "incpath.h"
      38                 :            : #include "debug.h"            /* For debug_hooks.  */
      39                 :            : #include "opts.h"
      40                 :            : #include "plugin.h"           /* For PLUGIN_INCLUDE_FILE event.  */
      41                 :            : #include "mkdeps.h"
      42                 :            : #include "dumpfile.h"
      43                 :            : #include "file-prefix-map.h"    /* add_*_prefix_map()  */
      44                 :            : 
      45                 :            : #ifndef DOLLARS_IN_IDENTIFIERS
      46                 :            : # define DOLLARS_IN_IDENTIFIERS true
      47                 :            : #endif
      48                 :            : 
      49                 :            : #ifndef TARGET_SYSTEM_ROOT
      50                 :            : # define TARGET_SYSTEM_ROOT NULL
      51                 :            : #endif
      52                 :            : 
      53                 :            : #ifndef TARGET_OPTF
      54                 :            : #define TARGET_OPTF(ARG)
      55                 :            : #endif
      56                 :            : 
      57                 :            : /* CPP's options.  */
      58                 :            : cpp_options *cpp_opts;
      59                 :            : 
      60                 :            : /* Input filename.  */
      61                 :            : static const char *this_input_filename;
      62                 :            : 
      63                 :            : /* Filename and stream for preprocessed output.  */
      64                 :            : static const char *out_fname;
      65                 :            : static FILE *out_stream;
      66                 :            : 
      67                 :            : /* Append dependencies to deps_file.  */
      68                 :            : static bool deps_append;
      69                 :            : 
      70                 :            : /* If dependency switches (-MF etc.) have been given.  */
      71                 :            : static bool deps_seen;
      72                 :            : 
      73                 :            : /* If -v seen.  */
      74                 :            : static bool verbose;
      75                 :            : 
      76                 :            : /* Dependency output file.  */
      77                 :            : static const char *deps_file;
      78                 :            : 
      79                 :            : /* The prefix given by -iprefix, if any.  */
      80                 :            : static const char *iprefix;
      81                 :            : 
      82                 :            : /* The multilib directory given by -imultilib, if any.  */
      83                 :            : static const char *imultilib;
      84                 :            : 
      85                 :            : /* The system root, if any.  Overridden by -isysroot.  */
      86                 :            : static const char *sysroot = TARGET_SYSTEM_ROOT;
      87                 :            : 
      88                 :            : /* Zero disables all standard directories for headers.  */
      89                 :            : static bool std_inc = true;
      90                 :            : 
      91                 :            : /* Zero disables the C++-specific standard directories for headers.  */
      92                 :            : static bool std_cxx_inc = true;
      93                 :            : 
      94                 :            : /* If the quote chain has been split by -I-.  */
      95                 :            : static bool quote_chain_split;
      96                 :            : 
      97                 :            : /* Number of deferred options.  */
      98                 :            : static size_t deferred_count;
      99                 :            : 
     100                 :            : /* Number of deferred options scanned for -include.  */
     101                 :            : static size_t include_cursor;
     102                 :            : 
     103                 :            : /* Dump files/flags to use during parsing.  */
     104                 :            : static FILE *original_dump_file = NULL;
     105                 :            : static dump_flags_t original_dump_flags;
     106                 :            : 
     107                 :            : /* Whether any standard preincluded header has been preincluded.  */
     108                 :            : static bool done_preinclude;
     109                 :            : 
     110                 :            : static void handle_OPT_d (const char *);
     111                 :            : static void set_std_cxx98 (int);
     112                 :            : static void set_std_cxx11 (int);
     113                 :            : static void set_std_cxx14 (int);
     114                 :            : static void set_std_cxx17 (int);
     115                 :            : static void set_std_cxx2a (int);
     116                 :            : static void set_std_c89 (int, int);
     117                 :            : static void set_std_c99 (int);
     118                 :            : static void set_std_c11 (int);
     119                 :            : static void set_std_c17 (int);
     120                 :            : static void set_std_c2x (int);
     121                 :            : static void check_deps_environment_vars (void);
     122                 :            : static void handle_deferred_opts (void);
     123                 :            : static void sanitize_cpp_opts (void);
     124                 :            : static void add_prefixed_path (const char *, incpath_kind);
     125                 :            : static void push_command_line_include (void);
     126                 :            : static void cb_file_change (cpp_reader *, const line_map_ordinary *);
     127                 :            : static void cb_dir_change (cpp_reader *, const char *);
     128                 :            : static void c_finish_options (void);
     129                 :            : 
     130                 :            : #ifndef STDC_0_IN_SYSTEM_HEADERS
     131                 :            : #define STDC_0_IN_SYSTEM_HEADERS 0
     132                 :            : #endif
     133                 :            : 
     134                 :            : /* Holds switches parsed by c_common_handle_option (), but whose
     135                 :            :    handling is deferred to c_common_post_options ().  */
     136                 :            : static void defer_opt (enum opt_code, const char *);
     137                 :            : static struct deferred_opt
     138                 :            : {
     139                 :            :   enum opt_code code;
     140                 :            :   const char *arg;
     141                 :            : } *deferred_opts;
     142                 :            : 
     143                 :            : 
     144                 :            : extern const unsigned int 
     145                 :            : c_family_lang_mask = (CL_C | CL_CXX | CL_ObjC | CL_ObjCXX);
     146                 :            : 
     147                 :            : /* Defer option CODE with argument ARG.  */
     148                 :            : static void
     149                 :     137975 : defer_opt (enum opt_code code, const char *arg)
     150                 :            : {
     151                 :     137975 :   deferred_opts[deferred_count].code = code;
     152                 :     137975 :   deferred_opts[deferred_count].arg = arg;
     153                 :     137975 :   deferred_count++;
     154                 :     137975 : }
     155                 :            : 
     156                 :            : /* Return language mask for option parsing.  */
     157                 :            : unsigned int
     158                 :     817957 : c_common_option_lang_mask (void)
     159                 :            : {
     160                 :     817957 :   static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
     161                 :            : 
     162                 :     817957 :   return lang_flags[c_language];
     163                 :            : }
     164                 :            : 
     165                 :            : /* Diagnostic finalizer for C/C++/Objective-C/Objective-C++.  */
     166                 :            : static void
     167                 :     196544 : c_diagnostic_finalizer (diagnostic_context *context,
     168                 :            :                         diagnostic_info *diagnostic,
     169                 :            :                         diagnostic_t)
     170                 :            : {
     171                 :     196544 :   char *saved_prefix = pp_take_prefix (context->printer);
     172                 :     196544 :   pp_set_prefix (context->printer, NULL);
     173                 :     196544 :   pp_newline (context->printer);
     174                 :     196544 :   diagnostic_show_locus (context, diagnostic->richloc, diagnostic->kind);
     175                 :            :   /* By default print macro expansion contexts in the diagnostic
     176                 :            :      finalizer -- for tokens resulting from macro expansion.  */
     177                 :     196544 :   virt_loc_aware_diagnostic_finalizer (context, diagnostic);
     178                 :     196544 :   pp_set_prefix (context->printer, saved_prefix);
     179                 :     196544 :   pp_flush (context->printer);
     180                 :     196544 : }
     181                 :            : 
     182                 :            : /* Common default settings for diagnostics.  */
     183                 :            : void
     184                 :     157057 : c_common_diagnostics_set_defaults (diagnostic_context *context)
     185                 :            : {
     186                 :     157057 :   diagnostic_finalizer (context) = c_diagnostic_finalizer;
     187                 :     157057 :   context->opt_permissive = OPT_fpermissive;
     188                 :     157057 : }
     189                 :            : 
     190                 :            : /* Whether options from all C-family languages should be accepted
     191                 :            :    quietly.  */
     192                 :            : static bool accept_all_c_family_options = false;
     193                 :            : 
     194                 :            : /* Return whether to complain about a wrong-language option.  */
     195                 :            : bool
     196                 :        185 : c_common_complain_wrong_lang_p (const struct cl_option *option)
     197                 :            : {
     198                 :        185 :   if (accept_all_c_family_options
     199                 :          0 :       && (option->flags & c_family_lang_mask))
     200                 :          0 :     return false;
     201                 :            : 
     202                 :            :   return true;
     203                 :            : }
     204                 :            : 
     205                 :            : /* Initialize options structure OPTS.  */
     206                 :            : void
     207                 :   23599300 : c_common_init_options_struct (struct gcc_options *opts)
     208                 :            : {
     209                 :   23599300 :   opts->x_flag_exceptions = c_dialect_cxx ();
     210                 :   23599300 :   opts->x_warn_pointer_arith = c_dialect_cxx ();
     211                 :   23599300 :   opts->x_warn_write_strings = c_dialect_cxx ();
     212                 :   23599300 :   opts->x_flag_warn_unused_result = true;
     213                 :            : 
     214                 :            :   /* By default, C99-like requirements for complex multiply and divide.  */
     215                 :   23599300 :   opts->x_flag_complex_method = 2;
     216                 :   23599300 : }
     217                 :            : 
     218                 :            : /* Common initialization before calling option handlers.  */
     219                 :            : void
     220                 :     157057 : c_common_init_options (unsigned int decoded_options_count,
     221                 :            :                        struct cl_decoded_option *decoded_options)
     222                 :            : {
     223                 :     157057 :   unsigned int i;
     224                 :     157057 :   struct cpp_callbacks *cb;
     225                 :            : 
     226                 :     157057 :   g_string_concat_db
     227                 :     157057 :     = new (ggc_alloc <string_concat_db> ()) string_concat_db ();
     228                 :            : 
     229                 :     235822 :   parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
     230                 :            :                                 ident_hash, line_table);
     231                 :     157057 :   cb = cpp_get_callbacks (parse_in);
     232                 :     157057 :   cb->diagnostic = c_cpp_diagnostic;
     233                 :            : 
     234                 :     157057 :   cpp_opts = cpp_get_options (parse_in);
     235                 :     157057 :   cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
     236                 :     157057 :   cpp_opts->objc = c_dialect_objc ();
     237                 :            : 
     238                 :            :   /* Reset to avoid warnings on internal definitions.  We set it just
     239                 :            :      before passing on command-line options to cpplib.  */
     240                 :     157057 :   cpp_opts->warn_dollars = 0;
     241                 :            : 
     242                 :     157057 :   deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count);
     243                 :            : 
     244                 :     157057 :   if (c_language == clk_c)
     245                 :            :     {
     246                 :            :       /* The default for C is gnu17.  */
     247                 :      78765 :       set_std_c17 (false /* ISO */);
     248                 :            : 
     249                 :            :       /* If preprocessing assembly language, accept any of the C-family
     250                 :            :          front end options since the driver may pass them through.  */
     251                 :    1615060 :       for (i = 1; i < decoded_options_count; i++)
     252                 :    1536870 :         if (decoded_options[i].opt_index == OPT_lang_asm)
     253                 :            :           {
     254                 :        577 :             accept_all_c_family_options = true;
     255                 :        577 :             break;
     256                 :            :           }
     257                 :            :     }
     258                 :            : 
     259                 :            :   /* Set C++ standard to C++14 if not specified on the command line.  */
     260                 :     157057 :   if (c_dialect_cxx ())
     261                 :      78292 :     set_std_cxx14 (/*ISO*/false);
     262                 :            : 
     263                 :     157057 :   global_dc->colorize_source_p = true;
     264                 :     157057 : }
     265                 :            : 
     266                 :            : /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
     267                 :            :    form of an -f or -W option was given.  Returns false if the switch was
     268                 :            :    invalid, true if valid.  Use HANDLERS in recursive handle_option calls.  */
     269                 :            : bool
     270                 :    2440640 : c_common_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
     271                 :            :                         int kind, location_t loc,
     272                 :            :                         const struct cl_option_handlers *handlers)
     273                 :            : {
     274                 :    2440640 :   const struct cl_option *option = &cl_options[scode];
     275                 :    2440640 :   enum opt_code code = (enum opt_code) scode;
     276                 :    2440640 :   bool result = true;
     277                 :            : 
     278                 :            :   /* Prevent resetting the language standard to a C dialect when the driver
     279                 :            :      has already determined that we're looking at assembler input.  */
     280                 :    2440640 :   bool preprocessing_asm_p = (cpp_get_options (parse_in)->lang == CLK_ASM);
     281                 :            : 
     282                 :    2440640 :   switch (code)
     283                 :            :     {
     284                 :     999302 :     default:
     285                 :     999302 :       if (cl_options[code].flags & c_family_lang_mask)
     286                 :            :         {
     287                 :     999302 :           if ((option->flags & CL_TARGET)
     288                 :     999302 :               && ! targetcm.handle_c_option (scode, arg, value))
     289                 :            :             result = false;
     290                 :            :           break;
     291                 :            :         }
     292                 :            :       result = false;
     293                 :            :       break;
     294                 :            : 
     295                 :        346 :     case OPT__output_pch_:
     296                 :        346 :       pch_file = arg;
     297                 :        346 :       break;
     298                 :            : 
     299                 :         10 :     case OPT_A:
     300                 :         10 :       defer_opt (code, arg);
     301                 :            :       break;
     302                 :            : 
     303                 :         14 :     case OPT_C:
     304                 :         14 :       cpp_opts->discard_comments = 0;
     305                 :         14 :       break;
     306                 :            : 
     307                 :         11 :     case OPT_CC:
     308                 :         11 :       cpp_opts->discard_comments = 0;
     309                 :         11 :       cpp_opts->discard_comments_in_macro_exp = 0;
     310                 :         11 :       break;
     311                 :            : 
     312                 :     126680 :     case OPT_D:
     313                 :     126680 :       defer_opt (code, arg);
     314                 :            :       break;
     315                 :            : 
     316                 :         21 :     case OPT_H:
     317                 :         21 :       cpp_opts->print_include_names = 1;
     318                 :         21 :       break;
     319                 :            : 
     320                 :            :     case OPT_F:
     321                 :            :       TARGET_OPTF (xstrdup (arg));
     322                 :            :       break;
     323                 :            : 
     324                 :     440998 :     case OPT_I:
     325                 :     440998 :       if (strcmp (arg, "-"))
     326                 :     440998 :         add_path (xstrdup (arg), INC_BRACKET, 0, true);
     327                 :            :       else
     328                 :            :         {
     329                 :          0 :           if (quote_chain_split)
     330                 :          0 :             error ("%<-I-%> specified twice");
     331                 :          0 :           quote_chain_split = true;
     332                 :          0 :           split_quote_chain ();
     333                 :          0 :           inform (input_location, "obsolete option %<-I-%> used, "
     334                 :            :                   "please use %<-iquote%> instead");
     335                 :            :         }
     336                 :            :       break;
     337                 :            : 
     338                 :         13 :     case OPT_M:
     339                 :         13 :     case OPT_MM:
     340                 :            :       /* When doing dependencies with -M or -MM, suppress normal
     341                 :            :          preprocessed output, but still do -dM etc. as software
     342                 :            :          depends on this.  Preprocessed output does occur if -MD, -MMD
     343                 :            :          or environment var dependency generation is used.  */
     344                 :         13 :       cpp_opts->deps.style = (code == OPT_M ? DEPS_SYSTEM: DEPS_USER);
     345                 :         13 :       flag_no_output = 1;
     346                 :         13 :       break;
     347                 :            : 
     348                 :       4845 :     case OPT_MD:
     349                 :       4845 :     case OPT_MMD:
     350                 :       4845 :       cpp_opts->deps.style = (code == OPT_MD ? DEPS_SYSTEM: DEPS_USER);
     351                 :       4845 :       cpp_opts->deps.need_preprocessor_output = true;
     352                 :       4845 :       deps_file = arg;
     353                 :       4845 :       break;
     354                 :            : 
     355                 :       4840 :     case OPT_MF:
     356                 :       4840 :       deps_seen = true;
     357                 :       4840 :       deps_file = arg;
     358                 :       4840 :       break;
     359                 :            : 
     360                 :          3 :     case OPT_MG:
     361                 :          3 :       deps_seen = true;
     362                 :          3 :       cpp_opts->deps.missing_files = true;
     363                 :          3 :       break;
     364                 :            : 
     365                 :       4840 :     case OPT_MP:
     366                 :       4840 :       deps_seen = true;
     367                 :       4840 :       cpp_opts->deps.phony_targets = true;
     368                 :       4840 :       break;
     369                 :            : 
     370                 :       4855 :     case OPT_MQ:
     371                 :       4855 :     case OPT_MT:
     372                 :       4855 :       deps_seen = true;
     373                 :       4855 :       defer_opt (code, arg);
     374                 :            :       break;
     375                 :            : 
     376                 :         31 :     case OPT_P:
     377                 :         31 :       flag_no_line_commands = 1;
     378                 :         31 :       break;
     379                 :            : 
     380                 :         17 :     case OPT_U:
     381                 :         17 :       defer_opt (code, arg);
     382                 :            :       break;
     383                 :            : 
     384                 :       8208 :     case OPT_Wall:
     385                 :            :       /* ??? Don't add new options here. Use LangEnabledBy in c.opt.  */
     386                 :            : 
     387                 :       8208 :       cpp_opts->warn_num_sign_change = value;
     388                 :       8208 :       break;
     389                 :            : 
     390                 :       8244 :     case OPT_Wunknown_pragmas:
     391                 :            :       /* Set to greater than 1, so that even unknown pragmas in
     392                 :            :          system headers will be warned about.  */
     393                 :            :       /* ??? There is no way to handle this automatically for now.  */
     394                 :       8244 :       warn_unknown_pragmas = value * 2;
     395                 :       8244 :       break;
     396                 :            : 
     397                 :        996 :     case OPT_ansi:
     398                 :        996 :       if (!c_dialect_cxx ())
     399                 :        804 :         set_std_c89 (false, true);
     400                 :            :       else
     401                 :        192 :         set_std_cxx98 (true);
     402                 :            :       break;
     403                 :            : 
     404                 :            :     case OPT_d:
     405                 :    2440640 :       handle_OPT_d (arg);
     406                 :            :       break;
     407                 :            : 
     408                 :        591 :     case OPT_Wabi_:
     409                 :        591 :       warn_abi = true;
     410                 :        591 :       if (value == 1)
     411                 :            :         {
     412                 :          0 :           warning (0, "%<-Wabi=1%> is not supported, using =2");
     413                 :          0 :           value = 2;
     414                 :            :         }
     415                 :        591 :       warn_abi_version = value;
     416                 :        591 :       break;
     417                 :            : 
     418                 :          0 :     case OPT_fcanonical_system_headers:
     419                 :          0 :       cpp_opts->canonical_system_headers = value;
     420                 :          0 :       break;
     421                 :            : 
     422                 :         12 :     case OPT_fcond_mismatch:
     423                 :         12 :       if (!c_dialect_cxx ())
     424                 :            :         {
     425                 :         12 :           flag_cond_mismatch = value;
     426                 :         12 :           break;
     427                 :            :         }
     428                 :          0 :       warning (0, "switch %qs is no longer supported", option->opt_text);
     429                 :          0 :       break;
     430                 :            : 
     431                 :        275 :     case OPT_fbuiltin_:
     432                 :        275 :       if (value)
     433                 :            :         result = false;
     434                 :            :       else
     435                 :        275 :         disable_builtin_function (arg);
     436                 :            :       break;
     437                 :            : 
     438                 :        590 :     case OPT_fdirectives_only:
     439                 :        590 :       cpp_opts->directives_only = value;
     440                 :        590 :       break;
     441                 :            : 
     442                 :          6 :     case OPT_fdollars_in_identifiers:
     443                 :          6 :       cpp_opts->dollars_in_ident = value;
     444                 :          6 :       break;
     445                 :            : 
     446                 :         10 :     case OPT_fmacro_prefix_map_:
     447                 :         10 :       add_macro_prefix_map (arg);
     448                 :         10 :       break;
     449                 :            : 
     450                 :         11 :     case OPT_ffreestanding:
     451                 :         11 :       value = !value;
     452                 :            :       /* Fall through.  */
     453                 :         19 :     case OPT_fhosted:
     454                 :         19 :       flag_hosted = value;
     455                 :         19 :       flag_no_builtin = !value;
     456                 :         19 :       break;
     457                 :            : 
     458                 :          0 :     case OPT_fconstant_string_class_:
     459                 :          0 :       constant_string_class_name = arg;
     460                 :          0 :       break;
     461                 :            : 
     462                 :          0 :     case OPT_fextended_identifiers:
     463                 :          0 :       cpp_opts->extended_identifiers = value;
     464                 :          0 :       break;
     465                 :            : 
     466                 :          5 :     case OPT_fmax_include_depth_:
     467                 :          5 :         cpp_opts->max_include_depth = value;
     468                 :          5 :       break;
     469                 :            : 
     470                 :          5 :     case OPT_foperator_names:
     471                 :          5 :       cpp_opts->operator_names = value;
     472                 :          5 :       break;
     473                 :            : 
     474                 :          0 :     case OPT_fpch_deps:
     475                 :          0 :       cpp_opts->restore_pch_deps = value;
     476                 :          0 :       break;
     477                 :            : 
     478                 :        126 :     case OPT_fpch_preprocess:
     479                 :        126 :       flag_pch_preprocess = value;
     480                 :        126 :       break;
     481                 :            : 
     482                 :        297 :     case OPT_fpermissive:
     483                 :        297 :       flag_permissive = value;
     484                 :        297 :       global_dc->permissive = value;
     485                 :        297 :       break;
     486                 :            : 
     487                 :        148 :     case OPT_fpreprocessed:
     488                 :        148 :       cpp_opts->preprocessed = value;
     489                 :        148 :       break;
     490                 :            : 
     491                 :          0 :     case OPT_fdebug_cpp:
     492                 :          0 :       cpp_opts->debug = 1;
     493                 :          0 :       break;
     494                 :            : 
     495                 :          1 :     case OPT_ftrack_macro_expansion:
     496                 :          1 :       if (value)
     497                 :          0 :         value = 2;
     498                 :            :       /* Fall Through.  */
     499                 :            : 
     500                 :        421 :     case OPT_ftrack_macro_expansion_:
     501                 :        421 :       if (arg && *arg != '\0')
     502                 :        420 :         cpp_opts->track_macro_expansion = value;
     503                 :            :       else
     504                 :          1 :         cpp_opts->track_macro_expansion = 2;
     505                 :            :       break;
     506                 :            : 
     507                 :          0 :     case OPT_ftabstop_:
     508                 :            :       /* It is documented that we silently ignore silly values.  */
     509                 :          0 :       if (value >= 1 && value <= 100)
     510                 :          0 :         cpp_opts->tabstop = value;
     511                 :            :       break;
     512                 :            : 
     513                 :         71 :     case OPT_fexec_charset_:
     514                 :         71 :       cpp_opts->narrow_charset = arg;
     515                 :         71 :       break;
     516                 :            : 
     517                 :          0 :     case OPT_fwide_exec_charset_:
     518                 :          0 :       cpp_opts->wide_charset = arg;
     519                 :          0 :       break;
     520                 :            : 
     521                 :         22 :     case OPT_finput_charset_:
     522                 :         22 :       cpp_opts->input_charset = arg;
     523                 :         22 :       break;
     524                 :            : 
     525                 :         35 :     case OPT_ftemplate_depth_:
     526                 :         35 :       max_tinst_depth = value;
     527                 :         35 :       break;
     528                 :            : 
     529                 :         28 :     case OPT_fvisibility_inlines_hidden:
     530                 :         28 :       visibility_options.inlines_hidden = value;
     531                 :         28 :       break;
     532                 :            : 
     533                 :         59 :     case OPT_femit_struct_debug_baseonly:
     534                 :         59 :       set_struct_debug_option (&global_options, loc, "base");
     535                 :         59 :       break;
     536                 :            : 
     537                 :         10 :     case OPT_femit_struct_debug_reduced:
     538                 :         10 :       set_struct_debug_option (&global_options, loc,
     539                 :            :                                "dir:ord:sys,dir:gen:any,ind:base");
     540                 :         10 :       break;
     541                 :            : 
     542                 :         15 :     case OPT_femit_struct_debug_detailed_:
     543                 :         15 :       set_struct_debug_option (&global_options, loc, arg);
     544                 :         15 :       break;
     545                 :            : 
     546                 :         15 :     case OPT_fext_numeric_literals:
     547                 :         15 :       cpp_opts->ext_numeric_literals = value;
     548                 :         15 :       break;
     549                 :            : 
     550                 :          0 :     case OPT_idirafter:
     551                 :          0 :       add_path (xstrdup (arg), INC_AFTER, 0, true);
     552                 :          0 :       break;
     553                 :            : 
     554                 :       6413 :     case OPT_imacros:
     555                 :       6413 :     case OPT_include:
     556                 :       6413 :       defer_opt (code, arg);
     557                 :            :       break;
     558                 :            : 
     559                 :       4403 :     case OPT_imultilib:
     560                 :       4403 :       imultilib = arg;
     561                 :       4403 :       break;
     562                 :            : 
     563                 :     156922 :     case OPT_iprefix:
     564                 :     156922 :       iprefix = arg;
     565                 :     156922 :       break;
     566                 :            : 
     567                 :       2240 :     case OPT_iquote:
     568                 :       2240 :       add_path (xstrdup (arg), INC_QUOTE, 0, true);
     569                 :       2240 :       break;
     570                 :            : 
     571                 :          0 :     case OPT_isysroot:
     572                 :          0 :       sysroot = arg;
     573                 :          0 :       break;
     574                 :            : 
     575                 :     353285 :     case OPT_isystem:
     576                 :     353285 :       add_path (xstrdup (arg), INC_SYSTEM, 0, true);
     577                 :     353285 :       break;
     578                 :            : 
     579                 :          0 :     case OPT_iwithprefix:
     580                 :          0 :       add_prefixed_path (arg, INC_SYSTEM);
     581                 :          0 :       break;
     582                 :            : 
     583                 :          0 :     case OPT_iwithprefixbefore:
     584                 :          0 :       add_prefixed_path (arg, INC_BRACKET);
     585                 :          0 :       break;
     586                 :            : 
     587                 :        577 :     case OPT_lang_asm:
     588                 :        577 :       cpp_set_lang (parse_in, CLK_ASM);
     589                 :        577 :       cpp_opts->dollars_in_ident = false;
     590                 :        577 :       break;
     591                 :            : 
     592                 :         31 :     case OPT_nostdinc:
     593                 :         31 :       std_inc = false;
     594                 :         31 :       break;
     595                 :            : 
     596                 :      86812 :     case OPT_nostdinc__:
     597                 :      86812 :       std_cxx_inc = false;
     598                 :      86812 :       break;
     599                 :            : 
     600                 :     156502 :     case OPT_o:
     601                 :     156502 :       if (!out_fname)
     602                 :     156502 :         out_fname = arg;
     603                 :            :       else
     604                 :          0 :         error ("output filename specified twice");
     605                 :            :       break;
     606                 :            : 
     607                 :          0 :     case OPT_print_objc_runtime_info:
     608                 :          0 :       print_struct_values = 1;
     609                 :          0 :       break;
     610                 :            : 
     611                 :          2 :     case OPT_remap:
     612                 :          2 :       cpp_opts->remap = 1;
     613                 :          2 :       break;
     614                 :            : 
     615                 :      11019 :     case OPT_std_c__98:
     616                 :      11019 :     case OPT_std_gnu__98:
     617                 :      11019 :       if (!preprocessing_asm_p)
     618                 :      11019 :         set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
     619                 :            :       break;
     620                 :            : 
     621                 :       1492 :     case OPT_std_c__11:
     622                 :       1492 :     case OPT_std_gnu__11:
     623                 :       1492 :       if (!preprocessing_asm_p)
     624                 :       1492 :         set_std_cxx11 (code == OPT_std_c__11 /* ISO */);
     625                 :            :       break;
     626                 :            : 
     627                 :      14654 :     case OPT_std_c__14:
     628                 :      14654 :     case OPT_std_gnu__14:
     629                 :      14654 :       if (!preprocessing_asm_p)
     630                 :      14654 :         set_std_cxx14 (code == OPT_std_c__14 /* ISO */);
     631                 :            :       break;
     632                 :            : 
     633                 :      16332 :     case OPT_std_c__17:
     634                 :      16332 :     case OPT_std_gnu__17:
     635                 :      16332 :       if (!preprocessing_asm_p)
     636                 :      16332 :         set_std_cxx17 (code == OPT_std_c__17 /* ISO */);
     637                 :            :       break;
     638                 :            : 
     639                 :      15860 :     case OPT_std_c__2a:
     640                 :      15860 :     case OPT_std_gnu__2a:
     641                 :      15860 :       if (!preprocessing_asm_p)
     642                 :      15860 :         set_std_cxx2a (code == OPT_std_c__2a /* ISO */);
     643                 :            :       break;
     644                 :            : 
     645                 :        182 :     case OPT_std_c90:
     646                 :        182 :     case OPT_std_iso9899_199409:
     647                 :        182 :       if (!preprocessing_asm_p)
     648                 :        182 :         set_std_c89 (code == OPT_std_iso9899_199409 /* c94 */, true /* ISO */);
     649                 :            :       break;
     650                 :            : 
     651                 :        214 :     case OPT_std_gnu90:
     652                 :        214 :       if (!preprocessing_asm_p)
     653                 :        214 :         set_std_c89 (false /* c94 */, false /* ISO */);
     654                 :            :       break;
     655                 :            : 
     656                 :        541 :     case OPT_std_c99:
     657                 :        541 :       if (!preprocessing_asm_p)
     658                 :        540 :         set_std_c99 (true /* ISO */);
     659                 :            :       break;
     660                 :            : 
     661                 :        508 :     case OPT_std_gnu99:
     662                 :        508 :       if (!preprocessing_asm_p)
     663                 :        508 :         set_std_c99 (false /* ISO */);
     664                 :            :       break;
     665                 :            : 
     666                 :        397 :     case OPT_std_c11:
     667                 :        397 :       if (!preprocessing_asm_p)
     668                 :        397 :         set_std_c11 (true /* ISO */);
     669                 :            :       break;
     670                 :            : 
     671                 :       2901 :     case OPT_std_gnu11:
     672                 :       2901 :       if (!preprocessing_asm_p)
     673                 :       2901 :         set_std_c11 (false /* ISO */);
     674                 :            :       break;
     675                 :            : 
     676                 :          5 :     case OPT_std_c17:
     677                 :          5 :       if (!preprocessing_asm_p)
     678                 :          5 :         set_std_c17 (true /* ISO */);
     679                 :            :       break;
     680                 :            : 
     681                 :          2 :     case OPT_std_gnu17:
     682                 :          2 :       if (!preprocessing_asm_p)
     683                 :          2 :         set_std_c17 (false /* ISO */);
     684                 :            :       break;
     685                 :            : 
     686                 :         54 :     case OPT_std_c2x:
     687                 :         54 :       if (!preprocessing_asm_p)
     688                 :         54 :         set_std_c2x (true /* ISO */);
     689                 :            :       break;
     690                 :            : 
     691                 :         15 :     case OPT_std_gnu2x:
     692                 :         15 :       if (!preprocessing_asm_p)
     693                 :         15 :         set_std_c2x (false /* ISO */);
     694                 :            :       break;
     695                 :            : 
     696                 :         19 :     case OPT_trigraphs:
     697                 :         19 :       cpp_opts->trigraphs = 1;
     698                 :         19 :       break;
     699                 :            : 
     700                 :         56 :     case OPT_traditional_cpp:
     701                 :         56 :       cpp_opts->traditional = 1;
     702                 :         56 :       break;
     703                 :            : 
     704                 :        112 :     case OPT_v:
     705                 :        112 :       verbose = true;
     706                 :        112 :       break;
     707                 :            :     }
     708                 :            : 
     709                 :    2440640 :   switch (c_language)
     710                 :            :     {
     711                 :     962833 :     case clk_c:
     712                 :     962833 :       C_handle_option_auto (&global_options, &global_options_set, 
     713                 :            :                             scode, arg, value, 
     714                 :            :                             c_family_lang_mask, kind,
     715                 :            :                             loc, handlers, global_dc);
     716                 :     962833 :       break;
     717                 :            : 
     718                 :          0 :     case clk_objc:
     719                 :          0 :       ObjC_handle_option_auto (&global_options, &global_options_set,
     720                 :            :                                scode, arg, value, 
     721                 :            :                                c_family_lang_mask, kind,
     722                 :            :                                loc, handlers, global_dc);
     723                 :          0 :       break;
     724                 :            : 
     725                 :    1477810 :     case clk_cxx:
     726                 :    1477810 :       CXX_handle_option_auto (&global_options, &global_options_set,
     727                 :            :                               scode, arg, value,
     728                 :            :                               c_family_lang_mask, kind,
     729                 :            :                               loc, handlers, global_dc);
     730                 :    1477810 :       break;
     731                 :            : 
     732                 :          0 :     case clk_objcxx:
     733                 :          0 :       ObjCXX_handle_option_auto (&global_options, &global_options_set,
     734                 :            :                                  scode, arg, value,
     735                 :            :                                  c_family_lang_mask, kind,
     736                 :            :                                  loc, handlers, global_dc);
     737                 :          0 :       break;
     738                 :            : 
     739                 :          0 :     default:
     740                 :          0 :       gcc_unreachable ();
     741                 :            :     }
     742                 :            : 
     743                 :    2440640 :   cpp_handle_option_auto (&global_options, scode, cpp_opts);
     744                 :    2440640 :   return result;
     745                 :            : }
     746                 :            : 
     747                 :            : /* Default implementation of TARGET_HANDLE_C_OPTION.  */
     748                 :            : 
     749                 :            : bool
     750                 :          0 : default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
     751                 :            :                          const char *arg ATTRIBUTE_UNUSED,
     752                 :            :                          int value ATTRIBUTE_UNUSED)
     753                 :            : {
     754                 :          0 :   return false;
     755                 :            : }
     756                 :            : 
     757                 :            : /* Post-switch processing.  */
     758                 :            : bool
     759                 :     156995 : c_common_post_options (const char **pfilename)
     760                 :            : {
     761                 :     156995 :   struct cpp_callbacks *cb;
     762                 :            : 
     763                 :            :   /* Canonicalize the input and output filenames.  */
     764                 :     156995 :   if (in_fnames == NULL)
     765                 :            :     {
     766                 :          0 :       in_fnames = XNEWVEC (const char *, 1);
     767                 :          0 :       in_fnames[0] = "";
     768                 :            :     }
     769                 :     156995 :   else if (strcmp (in_fnames[0], "-") == 0)
     770                 :            :     {
     771                 :        116 :       if (pch_file)
     772                 :          0 :         error ("cannot use %<-%> as input filename for a precompiled header");
     773                 :            : 
     774                 :        116 :       in_fnames[0] = "";
     775                 :            :     }
     776                 :            : 
     777                 :     156995 :   if (out_fname == NULL || !strcmp (out_fname, "-"))
     778                 :        555 :     out_fname = "";
     779                 :            : 
     780                 :     156995 :   if (cpp_opts->deps.style == DEPS_NONE)
     781                 :     152137 :     check_deps_environment_vars ();
     782                 :            : 
     783                 :     156995 :   handle_deferred_opts ();
     784                 :            : 
     785                 :     156995 :   sanitize_cpp_opts ();
     786                 :            : 
     787                 :     156995 :   register_include_chains (parse_in, sysroot, iprefix, imultilib,
     788                 :     156995 :                            std_inc, std_cxx_inc && c_dialect_cxx (), verbose);
     789                 :            : 
     790                 :            : #ifdef C_COMMON_OVERRIDE_OPTIONS
     791                 :            :   /* Some machines may reject certain combinations of C
     792                 :            :      language-specific options.  */
     793                 :            :   C_COMMON_OVERRIDE_OPTIONS;
     794                 :            : #endif
     795                 :            : 
     796                 :            :   /* Excess precision other than "fast" requires front-end
     797                 :            :      support.  */
     798                 :     156995 :   if (c_dialect_cxx ())
     799                 :            :     {
     800                 :      78291 :       if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
     801                 :          0 :         sorry ("%<-fexcess-precision=standard%> for C++");
     802                 :      78291 :       flag_excess_precision = EXCESS_PRECISION_FAST;
     803                 :            :     }
     804                 :      78704 :   else if (flag_excess_precision == EXCESS_PRECISION_DEFAULT)
     805                 :      77729 :     flag_excess_precision = (flag_iso ? EXCESS_PRECISION_STANDARD
     806                 :      77729 :                                       : EXCESS_PRECISION_FAST);
     807                 :            : 
     808                 :            :   /* ISO C restricts floating-point expression contraction to within
     809                 :            :      source-language expressions (-ffp-contract=on, currently an alias
     810                 :            :      for -ffp-contract=off).  */
     811                 :     156995 :   if (flag_iso
     812                 :     156995 :       && !c_dialect_cxx ()
     813                 :       1978 :       && (global_options_set.x_flag_fp_contract_mode
     814                 :            :           == (enum fp_contract_mode) 0)
     815                 :       1978 :       && flag_unsafe_math_optimizations == 0)
     816                 :       1976 :     flag_fp_contract_mode = FP_CONTRACT_OFF;
     817                 :            : 
     818                 :            :   /* If we are compiling C, and we are outside of a standards mode,
     819                 :            :      we can permit the new values from ISO/IEC TS 18661-3 for
     820                 :            :      FLT_EVAL_METHOD.  Otherwise, we must restrict the possible values to
     821                 :            :      the set specified in ISO C99/C11.  */
     822                 :     156995 :   if (!flag_iso
     823                 :     115025 :       && !c_dialect_cxx ()
     824                 :      76726 :       && (global_options_set.x_flag_permitted_flt_eval_methods
     825                 :            :           == PERMITTED_FLT_EVAL_METHODS_DEFAULT))
     826                 :      76725 :     flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_TS_18661;
     827                 :            :   else
     828                 :      80270 :     flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_C11;
     829                 :            : 
     830                 :            :   /* C2X Annex F does not permit certain built-in functions to raise
     831                 :            :      "inexact".  */
     832                 :     156995 :   if (flag_isoc2x)
     833                 :         69 :     SET_OPTION_IF_UNSET (&global_options, &global_options_set,
     834                 :            :                          flag_fp_int_builtin_inexact, 0);
     835                 :            : 
     836                 :            :   /* By default we use C99 inline semantics in GNU99 or C99 mode.  C99
     837                 :            :      inline semantics are not supported in GNU89 or C89 mode.  */
     838                 :     156995 :   if (flag_gnu89_inline == -1)
     839                 :     156617 :     flag_gnu89_inline = !flag_isoc99;
     840                 :        378 :   else if (!flag_gnu89_inline && !flag_isoc99)
     841                 :          1 :     error ("%<-fno-gnu89-inline%> is only supported in GNU99 or C99 mode");
     842                 :            : 
     843                 :            :   /* Default to ObjC sjlj exception handling if NeXT runtime.  */
     844                 :     156995 :   if (flag_objc_sjlj_exceptions < 0)
     845                 :     156995 :     flag_objc_sjlj_exceptions = flag_next_runtime;
     846                 :     156995 :   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
     847                 :          0 :     flag_exceptions = 1;
     848                 :            : 
     849                 :            :   /* If -ffreestanding, -fno-hosted or -fno-builtin then disable
     850                 :            :      pattern recognition.  */
     851                 :     156995 :   if (flag_no_builtin)
     852                 :        673 :     SET_OPTION_IF_UNSET (&global_options, &global_options_set,
     853                 :            :                          flag_tree_loop_distribute_patterns, 0);
     854                 :            : 
     855                 :            :   /* -Woverlength-strings is off by default, but is enabled by -Wpedantic.
     856                 :            :      It is never enabled in C++, as the minimum limit is not normative
     857                 :            :      in that standard.  */
     858                 :     156995 :   if (c_dialect_cxx ())
     859                 :      78291 :     warn_overlength_strings = 0;
     860                 :            : 
     861                 :            :   /* Wmain is enabled by default in C++ but not in C.  */
     862                 :            :   /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
     863                 :            :      even if -Wall or -Wpedantic was given (warn_main will be 2 if set
     864                 :            :      by -Wall, 1 if set by -Wmain).  */
     865                 :     156995 :   if (warn_main == -1)
     866                 :     182428 :     warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
     867                 :      45262 :   else if (warn_main == 2)
     868                 :      45114 :     warn_main = flag_hosted ? 1 : 0;
     869                 :            : 
     870                 :            :   /* In C, -Wall and -Wc++-compat enable -Wenum-compare; if it has not
     871                 :            :      yet been set, it is disabled by default.  In C++, it is enabled
     872                 :            :      by default.  */
     873                 :     156995 :   if (warn_enum_compare == -1)
     874                 :     150307 :     warn_enum_compare = c_dialect_cxx () ? 1 : 0;
     875                 :            : 
     876                 :            :   /* -Wpacked-bitfield-compat is on by default for the C languages.  The
     877                 :            :      warning is issued in stor-layout.c which is not part of the front-end so
     878                 :            :      we need to selectively turn it on here.  */
     879                 :     156995 :   if (warn_packed_bitfield_compat == -1)
     880                 :     156985 :     warn_packed_bitfield_compat = 1;
     881                 :            : 
     882                 :            :   /* Special format checking options don't work without -Wformat; warn if
     883                 :            :      they are used.  */
     884                 :     156995 :   if (!warn_format)
     885                 :            :     {
     886                 :     148464 :       warning (OPT_Wformat_y2k,
     887                 :            :                "%<-Wformat-y2k%> ignored without %<-Wformat%>");
     888                 :     148464 :       warning (OPT_Wformat_extra_args,
     889                 :            :                "%<-Wformat-extra-args%> ignored without %<-Wformat%>");
     890                 :     148464 :       warning (OPT_Wformat_zero_length,
     891                 :            :                "%<-Wformat-zero-length%> ignored without %<-Wformat%>");
     892                 :     148464 :       warning (OPT_Wformat_nonliteral,
     893                 :            :                "%<-Wformat-nonliteral%> ignored without %<-Wformat%>");
     894                 :     148464 :       warning (OPT_Wformat_contains_nul,
     895                 :            :                "%<-Wformat-contains-nul%> ignored without %<-Wformat%>");
     896                 :     148464 :       warning (OPT_Wformat_security,
     897                 :            :                "%<-Wformat-security%> ignored without %<-Wformat%>");
     898                 :            :     }
     899                 :            : 
     900                 :            :   /* -Wimplicit-function-declaration is enabled by default for C99.  */
     901                 :     156995 :   if (warn_implicit_function_declaration == -1)
     902                 :     150931 :     warn_implicit_function_declaration = flag_isoc99;
     903                 :            : 
     904                 :            :   /* -Wimplicit-int is enabled by default for C99.  */
     905                 :     156995 :   if (warn_implicit_int == -1)
     906                 :     150977 :     warn_implicit_int = flag_isoc99;
     907                 :            : 
     908                 :            :   /* -Wold-style-definition is enabled by default for C2X.  */
     909                 :     156995 :   if (warn_old_style_definition == -1)
     910                 :     153799 :     warn_old_style_definition = flag_isoc2x;
     911                 :            : 
     912                 :            :   /* -Wshift-overflow is enabled by default in C99 and C++11 modes.  */
     913                 :     156995 :   if (warn_shift_overflow == -1)
     914                 :     169289 :     warn_shift_overflow = cxx_dialect >= cxx11 || flag_isoc99;
     915                 :            : 
     916                 :            :   /* -Wshift-negative-value is enabled by -Wextra in C99 and C++11 modes.  */
     917                 :     156995 :   if (warn_shift_negative_value == -1)
     918                 :     313972 :     warn_shift_negative_value = (extra_warnings
     919                 :     308218 :                                  && (cxx_dialect >= cxx11 || flag_isoc99));
     920                 :            : 
     921                 :            :   /* -Wregister is enabled by default in C++17.  */
     922                 :     156995 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set, warn_register,
     923                 :            :                        cxx_dialect >= cxx17);
     924                 :            : 
     925                 :            :   /* -Wcomma-subscript is enabled by default in C++20.  */
     926                 :     298205 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set,
     927                 :            :                        warn_comma_subscript,
     928                 :            :                        cxx_dialect >= cxx2a && warn_deprecated);
     929                 :            : 
     930                 :            :   /* -Wvolatile is enabled by default in C++20.  */
     931                 :     298180 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set, warn_volatile,
     932                 :            :                        cxx_dialect >= cxx2a && warn_deprecated);
     933                 :            : 
     934                 :            :   /* Declone C++ 'structors if -Os.  */
     935                 :     156995 :   if (flag_declone_ctor_dtor == -1)
     936                 :     156969 :     flag_declone_ctor_dtor = optimize_size;
     937                 :            : 
     938                 :     156995 :   if (flag_abi_compat_version == 1)
     939                 :            :     {
     940                 :          0 :       warning (0, "%<-fabi-compat-version=1%> is not supported, using =2");
     941                 :          0 :       flag_abi_compat_version = 2;
     942                 :            :     }
     943                 :            : 
     944                 :            :   /* Change flag_abi_version to be the actual current ABI level, for the
     945                 :            :      benefit of c_cpp_builtins, and to make comparison simpler.  */
     946                 :     156995 :   const int latest_abi_version = 14;
     947                 :            :   /* Generate compatibility aliases for ABI v11 (7.1) by default.  */
     948                 :     156995 :   const int abi_compat_default = 11;
     949                 :            : 
     950                 :            : #define clamp(X) if (X == 0 || X > latest_abi_version) X = latest_abi_version
     951                 :     156995 :   clamp (flag_abi_version);
     952                 :     156995 :   clamp (warn_abi_version);
     953                 :     156995 :   clamp (flag_abi_compat_version);
     954                 :            : #undef clamp
     955                 :            : 
     956                 :            :   /* Default -Wabi= or -fabi-compat-version= from each other.  */
     957                 :     156995 :   if (warn_abi_version == -1 && flag_abi_compat_version != -1)
     958                 :          0 :     warn_abi_version = flag_abi_compat_version;
     959                 :     156995 :   else if (flag_abi_compat_version == -1 && warn_abi_version != -1)
     960                 :        589 :     flag_abi_compat_version = warn_abi_version;
     961                 :     156406 :   else if (warn_abi_version == -1 && flag_abi_compat_version == -1)
     962                 :            :     {
     963                 :     156406 :       warn_abi_version = latest_abi_version;
     964                 :     156406 :       if (flag_abi_version == latest_abi_version)
     965                 :            :         {
     966                 :     156168 :           auto_diagnostic_group d;
     967                 :     156168 :           if (warning (OPT_Wabi, "%<-Wabi%> won%'t warn about anything"))
     968                 :            :             {
     969                 :          0 :               inform (input_location, "%<-Wabi%> warns about differences "
     970                 :            :                       "from the most up-to-date ABI, which is also used "
     971                 :            :                       "by default");
     972                 :          0 :               inform (input_location, "use e.g. %<-Wabi=11%> to warn about "
     973                 :            :                       "changes from GCC 7");
     974                 :            :             }
     975                 :     156168 :           flag_abi_compat_version = abi_compat_default;
     976                 :            :         }
     977                 :            :       else
     978                 :        238 :         flag_abi_compat_version = latest_abi_version;
     979                 :            :     }
     980                 :            : 
     981                 :            :   /* By default, enable the new inheriting constructor semantics along with ABI
     982                 :            :      11.  New and old should coexist fine, but it is a change in what
     983                 :            :      artificial symbols are generated.  */
     984                 :     156995 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set,
     985                 :            :                        flag_new_inheriting_ctors,
     986                 :            :                        abi_version_at_least (11));
     987                 :            : 
     988                 :            :   /* For GCC 7, only enable DR150 resolution by default if -std=c++17.  */
     989                 :     156995 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set, flag_new_ttp,
     990                 :            :                        cxx_dialect >= cxx17);
     991                 :            : 
     992                 :     156995 :   if (cxx_dialect >= cxx11)
     993                 :            :     {
     994                 :            :       /* If we're allowing C++0x constructs, don't warn about C++98
     995                 :            :          identifiers which are keywords in C++0x.  */
     996                 :      67154 :       warn_cxx11_compat = 0;
     997                 :      67154 :       cpp_opts->cpp_warn_cxx11_compat = 0;
     998                 :            : 
     999                 :      67154 :       if (warn_narrowing == -1)
    1000                 :      65256 :         warn_narrowing = 1;
    1001                 :            : 
    1002                 :            :       /* Unless -f{,no-}ext-numeric-literals has been used explicitly,
    1003                 :            :          for -std=c++{11,14,17,2a} default to -fno-ext-numeric-literals.  */
    1004                 :      67154 :       if (flag_iso && !global_options_set.x_flag_ext_numeric_literals)
    1005                 :      32758 :         cpp_opts->ext_numeric_literals = 0;
    1006                 :            :     }
    1007                 :      89841 :   else if (warn_narrowing == -1)
    1008                 :      88723 :     warn_narrowing = 0;
    1009                 :            : 
    1010                 :            :   /* C++17 has stricter evaluation order requirements; let's use some of them
    1011                 :            :      for earlier C++ as well, so chaining works as expected.  */
    1012                 :     156995 :   if (c_dialect_cxx ()
    1013                 :      78291 :       && flag_strong_eval_order == -1)
    1014                 :     124458 :     flag_strong_eval_order = (cxx_dialect >= cxx17 ? 2 : 1);
    1015                 :            : 
    1016                 :            :   /* Global sized deallocation is new in C++14.  */
    1017                 :     156995 :   if (flag_sized_deallocation == -1)
    1018                 :     156992 :     flag_sized_deallocation = (cxx_dialect >= cxx14);
    1019                 :            : 
    1020                 :            :   /* char8_t support is new in C++2A.  */
    1021                 :     156995 :   if (flag_char8_t == -1)
    1022                 :     156889 :     flag_char8_t = (cxx_dialect >= cxx2a);
    1023                 :            : 
    1024                 :     156995 :   if (flag_extern_tls_init)
    1025                 :            :     {
    1026                 :     156993 :       if (!TARGET_SUPPORTS_ALIASES || !SUPPORTS_WEAK)
    1027                 :            :         {
    1028                 :            :           /* Lazy TLS initialization for a variable in another TU requires
    1029                 :            :              alias and weak reference support.  */
    1030                 :            :           if (flag_extern_tls_init > 0)
    1031                 :            :             sorry ("external TLS initialization functions not supported "
    1032                 :            :                    "on this target");
    1033                 :            : 
    1034                 :            :           flag_extern_tls_init = 0;
    1035                 :            :         }
    1036                 :            :       else
    1037                 :     156993 :         flag_extern_tls_init = 1;
    1038                 :            :     }
    1039                 :            : 
    1040                 :            :   /* Enable by default only for C++ and C++ with ObjC extensions.  */
    1041                 :     156995 :   if (warn_return_type == -1 && c_dialect_cxx ())
    1042                 :      75096 :     warn_return_type = 1;
    1043                 :            : 
    1044                 :            :   /* C++2a is the final version of concepts. We still use -fconcepts
    1045                 :            :      to know when concepts are enabled. Note that -fconcepts-ts can
    1046                 :            :      be used to include additional features, although modified to
    1047                 :            :      work with the standard.  */
    1048                 :     156995 :   if (cxx_dialect >= cxx2a || flag_concepts_ts)
    1049                 :      15817 :     flag_concepts = 1;
    1050                 :     141178 :   else if (flag_concepts)
    1051                 :            :     /* For -std=c++17 -fconcepts, imply -fconcepts-ts.  */
    1052                 :        159 :     flag_concepts_ts = 1;
    1053                 :            : 
    1054                 :     156995 :   if (num_in_fnames > 1)
    1055                 :          0 :     error ("too many filenames given; type %<%s %s%> for usage",
    1056                 :            :            progname, "--help");
    1057                 :            : 
    1058                 :     156995 :   if (flag_preprocess_only)
    1059                 :            :     {
    1060                 :            :       /* Open the output now.  We must do so even if flag_no_output is
    1061                 :            :          on, because there may be other output than from the actual
    1062                 :            :          preprocessing (e.g. from -dM).  */
    1063                 :       1930 :       if (out_fname[0] == '\0')
    1064                 :        555 :         out_stream = stdout;
    1065                 :            :       else
    1066                 :       1375 :         out_stream = fopen (out_fname, "w");
    1067                 :            : 
    1068                 :       1930 :       if (out_stream == NULL)
    1069                 :            :         {
    1070                 :          0 :           fatal_error (input_location, "opening output file %s: %m", out_fname);
    1071                 :            :           return false;
    1072                 :            :         }
    1073                 :            : 
    1074                 :       1930 :       init_pp_output (out_stream);
    1075                 :            :     }
    1076                 :            :   else
    1077                 :            :     {
    1078                 :     155065 :       init_c_lex ();
    1079                 :            : 
    1080                 :            :       /* When writing a PCH file, avoid reading some other PCH file,
    1081                 :            :          because the default address space slot then can't be used
    1082                 :            :          for the output PCH file.  */
    1083                 :     155065 :       if (pch_file)
    1084                 :            :         {
    1085                 :        346 :           c_common_no_more_pch ();
    1086                 :            :           /* Only -g0 and -gdwarf* are supported with PCH, for other
    1087                 :            :              debug formats we warn here and refuse to load any PCH files.  */
    1088                 :        346 :           if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
    1089                 :          0 :             warning (OPT_Wdeprecated,
    1090                 :            :                      "the %qs debug format cannot be used with "
    1091                 :          0 :                      "pre-compiled headers", debug_type_names[write_symbols]);
    1092                 :            :         }
    1093                 :     154719 :       else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
    1094                 :       3115 :         c_common_no_more_pch ();
    1095                 :            : 
    1096                 :            :       /* Yuk.  WTF is this?  I do know ObjC relies on it somewhere.  */
    1097                 :     155065 :       input_location = UNKNOWN_LOCATION;
    1098                 :            :     }
    1099                 :            : 
    1100                 :     156995 :   cb = cpp_get_callbacks (parse_in);
    1101                 :     156995 :   cb->file_change = cb_file_change;
    1102                 :     156995 :   cb->dir_change = cb_dir_change;
    1103                 :     156995 :   cpp_post_options (parse_in);
    1104                 :     156995 :   init_global_opts_from_cpp (&global_options, cpp_get_options (parse_in));
    1105                 :            : 
    1106                 :     156995 :   input_location = UNKNOWN_LOCATION;
    1107                 :            : 
    1108                 :     313990 :   *pfilename = this_input_filename
    1109                 :     156995 :     = cpp_read_main_file (parse_in, in_fnames[0]);
    1110                 :            :   /* Don't do any compilation or preprocessing if there is no input file.  */
    1111                 :     156995 :   if (this_input_filename == NULL)
    1112                 :            :     {
    1113                 :          0 :       errorcount++;
    1114                 :          0 :       return false;
    1115                 :            :     }
    1116                 :            : 
    1117                 :     156995 :   if (flag_working_directory
    1118                 :      33731 :       && flag_preprocess_only && !flag_no_line_commands)
    1119                 :        597 :     pp_dir_change (parse_in, get_src_pwd ());
    1120                 :            : 
    1121                 :            :   /* Disable LTO output when outputting a precompiled header.  */
    1122                 :     156995 :   if (pch_file && flag_lto)
    1123                 :            :     {
    1124                 :          0 :       flag_lto = 0;
    1125                 :          0 :       flag_generate_lto = 0;
    1126                 :            :     }
    1127                 :            : 
    1128                 :     156995 :   return flag_preprocess_only;
    1129                 :            : }
    1130                 :            : 
    1131                 :            : /* Front end initialization common to C, ObjC and C++.  */
    1132                 :            : bool
    1133                 :     156836 : c_common_init (void)
    1134                 :            : {
    1135                 :            :   /* Set up preprocessor arithmetic.  Must be done after call to
    1136                 :            :      c_common_nodes_and_builtins for type nodes to be good.  */
    1137                 :     156836 :   cpp_opts->precision = TYPE_PRECISION (intmax_type_node);
    1138                 :     156836 :   cpp_opts->char_precision = TYPE_PRECISION (char_type_node);
    1139                 :     156836 :   cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);
    1140                 :     156836 :   cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);
    1141                 :     156836 :   cpp_opts->unsigned_wchar = TYPE_UNSIGNED (wchar_type_node);
    1142                 :     156836 :   cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;
    1143                 :            : 
    1144                 :            :   /* This can't happen until after wchar_precision and bytes_big_endian
    1145                 :            :      are known.  */
    1146                 :     156836 :   cpp_init_iconv (parse_in);
    1147                 :            : 
    1148                 :     156836 :   if (version_flag)
    1149                 :            :     {
    1150                 :        109 :       int i;
    1151                 :        109 :       fputs ("Compiler executable checksum: ", stderr);
    1152                 :       1853 :       for (i = 0; i < 16; i++)
    1153                 :       1744 :         fprintf (stderr, "%02x", executable_checksum[i]);
    1154                 :        109 :       putc ('\n', stderr);
    1155                 :            :     }
    1156                 :            : 
    1157                 :            :   /* Has to wait until now so that cpplib has its hash table.  */
    1158                 :     156836 :   init_pragma ();
    1159                 :            : 
    1160                 :     156836 :   if (flag_preprocess_only)
    1161                 :            :     {
    1162                 :       1928 :       c_finish_options ();
    1163                 :       1928 :       preprocess_file (parse_in);
    1164                 :       1928 :       return false;
    1165                 :            :     }
    1166                 :            : 
    1167                 :            :   return true;
    1168                 :            : }
    1169                 :            : 
    1170                 :            : /* Initialize the integrated preprocessor after debug output has been
    1171                 :            :    initialized; loop over each input file.  */
    1172                 :            : void
    1173                 :     154908 : c_common_parse_file (void)
    1174                 :            : {
    1175                 :     154908 :   unsigned int i;
    1176                 :            : 
    1177                 :     154908 :   i = 0;
    1178                 :     154908 :   for (;;)
    1179                 :            :     {
    1180                 :     154908 :       c_finish_options ();
    1181                 :            :       /* Open the dump file to use for the original dump output
    1182                 :            :          here, to be used during parsing for the current file.  */
    1183                 :     154908 :       original_dump_file = dump_begin (TDI_original, &original_dump_flags);
    1184                 :     154908 :       pch_init ();
    1185                 :     154908 :       push_file_scope ();
    1186                 :     154908 :       c_parse_file ();
    1187                 :     154730 :       pop_file_scope ();
    1188                 :            :       /* And end the main input file, if the debug writer wants it  */
    1189                 :     154730 :       if (debug_hooks->start_end_main_source_file)
    1190                 :      29947 :         (*debug_hooks->end_source_file) (0);
    1191                 :     154730 :       if (++i >= num_in_fnames)
    1192                 :            :         break;
    1193                 :          0 :       cpp_undef_all (parse_in);
    1194                 :          0 :       cpp_clear_file_cache (parse_in);
    1195                 :          0 :       this_input_filename
    1196                 :          0 :         = cpp_read_main_file (parse_in, in_fnames[i]);
    1197                 :          0 :       if (original_dump_file)
    1198                 :            :         {
    1199                 :          0 :           dump_end (TDI_original, original_dump_file);
    1200                 :          0 :           original_dump_file = NULL;
    1201                 :            :         }
    1202                 :            :       /* If an input file is missing, abandon further compilation.
    1203                 :            :          cpplib has issued a diagnostic.  */
    1204                 :          0 :       if (!this_input_filename)
    1205                 :            :         break;
    1206                 :            :     }
    1207                 :            : 
    1208                 :     154730 :   c_parse_final_cleanups ();
    1209                 :     154715 : }
    1210                 :            : 
    1211                 :            : /* Returns the appropriate dump file for PHASE to dump with FLAGS.  */
    1212                 :            : 
    1213                 :            : FILE *
    1214                 :   30037400 : get_dump_info (int phase, dump_flags_t *flags)
    1215                 :            : {
    1216                 :   30037400 :   gcc_assert (phase == TDI_original);
    1217                 :            : 
    1218                 :   30037400 :   *flags = original_dump_flags;
    1219                 :   30037400 :   return original_dump_file;
    1220                 :            : }
    1221                 :            : 
    1222                 :            : /* Common finish hook for the C, ObjC and C++ front ends.  */
    1223                 :            : void
    1224                 :     156521 : c_common_finish (void)
    1225                 :            : {
    1226                 :     156521 :   FILE *deps_stream = NULL;
    1227                 :            : 
    1228                 :            :   /* Note that we write the dependencies even if there are errors. This is
    1229                 :            :      useful for handling outdated generated headers that now trigger errors
    1230                 :            :      (for example, with #error) which would be resolved by re-generating
    1231                 :            :      them. In a sense, this complements -MG.  */
    1232                 :     156521 :   if (cpp_opts->deps.style != DEPS_NONE)
    1233                 :            :     {
    1234                 :            :       /* If -M or -MM was seen without -MF, default output to the
    1235                 :            :          output stream.  */
    1236                 :       4853 :       if (!deps_file)
    1237                 :         13 :         deps_stream = out_stream;
    1238                 :       4840 :       else if (deps_file[0] == '-' && deps_file[1] == '\0')
    1239                 :          0 :         deps_stream = stdout;
    1240                 :            :       else
    1241                 :            :         {
    1242                 :       9680 :           deps_stream = fopen (deps_file, deps_append ? "a": "w");
    1243                 :       4840 :           if (!deps_stream)
    1244                 :          0 :             fatal_error (input_location, "opening dependency file %s: %m",
    1245                 :            :                          deps_file);
    1246                 :            :         }
    1247                 :            :     }
    1248                 :            : 
    1249                 :            :   /* For performance, avoid tearing down cpplib's internal structures
    1250                 :            :      with cpp_destroy ().  */
    1251                 :     156521 :   cpp_finish (parse_in, deps_stream);
    1252                 :            : 
    1253                 :       4853 :   if (deps_stream && deps_stream != out_stream && deps_stream != stdout
    1254                 :     161361 :       && (ferror (deps_stream) || fclose (deps_stream)))
    1255                 :          0 :     fatal_error (input_location, "closing dependency file %s: %m", deps_file);
    1256                 :            : 
    1257                 :     156521 :   if (out_stream && (ferror (out_stream) || fclose (out_stream)))
    1258                 :          0 :     fatal_error (input_location, "when writing output to %s: %m", out_fname);
    1259                 :     156521 : }
    1260                 :            : 
    1261                 :            : /* Either of two environment variables can specify output of
    1262                 :            :    dependencies.  Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
    1263                 :            :    DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
    1264                 :            :    and DEPS_TARGET is the target to mention in the deps.  They also
    1265                 :            :    result in dependency information being appended to the output file
    1266                 :            :    rather than overwriting it, and like Sun's compiler
    1267                 :            :    SUNPRO_DEPENDENCIES suppresses the dependency on the main file.  */
    1268                 :            : static void
    1269                 :     152137 : check_deps_environment_vars (void)
    1270                 :            : {
    1271                 :     152137 :   char *spec;
    1272                 :            : 
    1273                 :     152137 :   spec = getenv ("DEPENDENCIES_OUTPUT");
    1274                 :     152137 :   if (spec)
    1275                 :          0 :     cpp_opts->deps.style = DEPS_USER;
    1276                 :            :   else
    1277                 :            :     {
    1278                 :     152137 :       spec = getenv ("SUNPRO_DEPENDENCIES");
    1279                 :     152137 :       if (spec)
    1280                 :            :         {
    1281                 :          0 :           cpp_opts->deps.style = DEPS_SYSTEM;
    1282                 :          0 :           cpp_opts->deps.ignore_main_file = true;
    1283                 :            :         }
    1284                 :            :     }
    1285                 :            : 
    1286                 :     152137 :   if (spec)
    1287                 :            :     {
    1288                 :            :       /* Find the space before the DEPS_TARGET, if there is one.  */
    1289                 :          0 :       char *s = strchr (spec, ' ');
    1290                 :          0 :       if (s)
    1291                 :            :         {
    1292                 :            :           /* Let the caller perform MAKE quoting.  */
    1293                 :          0 :           defer_opt (OPT_MT, s + 1);
    1294                 :          0 :           *s = '\0';
    1295                 :            :         }
    1296                 :            : 
    1297                 :            :       /* Command line -MF overrides environment variables and default.  */
    1298                 :          0 :       if (!deps_file)
    1299                 :          0 :         deps_file = spec;
    1300                 :            : 
    1301                 :          0 :       deps_append = 1;
    1302                 :          0 :       deps_seen = true;
    1303                 :            :     }
    1304                 :     152137 : }
    1305                 :            : 
    1306                 :            : /* Handle deferred command line switches.  */
    1307                 :            : static void
    1308                 :     156995 : handle_deferred_opts (void)
    1309                 :            : {
    1310                 :            :   /* Avoid allocating the deps buffer if we don't need it.
    1311                 :            :      (This flag may be true without there having been -MT or -MQ
    1312                 :            :      options, but we'll still need the deps buffer.)  */
    1313                 :     156995 :   if (!deps_seen)
    1314                 :            :     return;
    1315                 :            : 
    1316                 :       4852 :   mkdeps *deps = cpp_get_deps (parse_in);
    1317                 :            : 
    1318                 :      29178 :   for (size_t i = 0; i < deferred_count; i++)
    1319                 :            :     {
    1320                 :      24326 :       struct deferred_opt *opt = &deferred_opts[i];
    1321                 :            : 
    1322                 :      24326 :       if (opt->code == OPT_MT || opt->code == OPT_MQ)
    1323                 :       4855 :         deps_add_target (deps, opt->arg, opt->code == OPT_MQ);
    1324                 :            :     }
    1325                 :            : }
    1326                 :            : 
    1327                 :            : /* These settings are appropriate for GCC, but not necessarily so for
    1328                 :            :    cpplib as a library.  */
    1329                 :            : static void
    1330                 :     156995 : sanitize_cpp_opts (void)
    1331                 :            : {
    1332                 :            :   /* If we don't know what style of dependencies to output, complain
    1333                 :            :      if any other dependency switches have been given.  */
    1334                 :     156995 :   if (deps_seen && cpp_opts->deps.style == DEPS_NONE)
    1335                 :          0 :     error ("to generate dependencies you must specify either %<-M%> "
    1336                 :            :            "or %<-MM%>");
    1337                 :            : 
    1338                 :            :   /* -dM and dependencies suppress normal output; do it here so that
    1339                 :            :      the last -d[MDN] switch overrides earlier ones.  */
    1340                 :     156995 :   if (flag_dump_macros == 'M')
    1341                 :         79 :     flag_no_output = 1;
    1342                 :            : 
    1343                 :            :   /* By default, -fdirectives-only implies -dD.  This allows subsequent phases
    1344                 :            :      to perform proper macro expansion.  */
    1345                 :     156995 :   if (cpp_opts->directives_only && !cpp_opts->preprocessed && !flag_dump_macros)
    1346                 :         11 :     flag_dump_macros = 'D';
    1347                 :            : 
    1348                 :            :   /* Disable -dD, -dN and -dI if normal output is suppressed.  Allow
    1349                 :            :      -dM since at least glibc relies on -M -dM to work.  */
    1350                 :            :   /* Also, flag_no_output implies flag_no_line_commands, always.  */
    1351                 :     156995 :   if (flag_no_output)
    1352                 :            :     {
    1353                 :         91 :       if (flag_dump_macros != 'M')
    1354                 :         12 :         flag_dump_macros = 0;
    1355                 :         91 :       flag_dump_includes = 0;
    1356                 :         91 :       flag_no_line_commands = 1;
    1357                 :            :     }
    1358                 :     156904 :   else if (cpp_opts->deps.missing_files)
    1359                 :          1 :     error ("%<-MG%> may only be used with %<-M%> or %<-MM%>");
    1360                 :            : 
    1361                 :     156995 :   cpp_opts->unsigned_char = !flag_signed_char;
    1362                 :     156995 :   cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
    1363                 :            : 
    1364                 :            :   /* Wlong-long is disabled by default. It is enabled by:
    1365                 :            :       [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or
    1366                 :            :       [-Wpedantic | -Wtraditional] -std=non-c99 
    1367                 :            : 
    1368                 :            :       Either -Wlong-long or -Wno-long-long override any other settings.
    1369                 :            :       ??? These conditions should be handled in c.opt.  */
    1370                 :     156995 :   if (warn_long_long == -1)
    1371                 :            :     {
    1372                 :     117830 :       warn_long_long = ((pedantic || warn_traditional)
    1373                 :     120436 :                         && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
    1374                 :     120415 :       cpp_opts->cpp_warn_long_long = warn_long_long;
    1375                 :            :     }
    1376                 :            : 
    1377                 :            :   /* If we're generating preprocessor output, emit current directory
    1378                 :            :      if explicitly requested or if debugging information is enabled.
    1379                 :            :      ??? Maybe we should only do it for debugging formats that
    1380                 :            :      actually output the current directory?  */
    1381                 :     156995 :   if (flag_working_directory == -1)
    1382                 :     156396 :     flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
    1383                 :            : 
    1384                 :     156995 :   if (warn_implicit_fallthrough < 5)
    1385                 :     156990 :     cpp_opts->cpp_warn_implicit_fallthrough = warn_implicit_fallthrough;
    1386                 :            :   else
    1387                 :          5 :     cpp_opts->cpp_warn_implicit_fallthrough = 0;
    1388                 :            : 
    1389                 :     156995 :   if (cpp_opts->directives_only)
    1390                 :            :     {
    1391                 :         13 :       if (cpp_warn_unused_macros)
    1392                 :          1 :         error ("%<-fdirectives-only%> is incompatible "
    1393                 :            :                "with %<-Wunused-macros%>");
    1394                 :         13 :       if (cpp_opts->traditional)
    1395                 :          1 :         error ("%<-fdirectives-only%> is incompatible with %<-traditional%>");
    1396                 :            :     }
    1397                 :     156995 : }
    1398                 :            : 
    1399                 :            : /* Add include path with a prefix at the front of its name.  */
    1400                 :            : static void
    1401                 :          0 : add_prefixed_path (const char *suffix, incpath_kind chain)
    1402                 :            : {
    1403                 :          0 :   char *path;
    1404                 :          0 :   const char *prefix;
    1405                 :          0 :   size_t prefix_len, suffix_len;
    1406                 :            : 
    1407                 :          0 :   suffix_len = strlen (suffix);
    1408                 :          0 :   prefix     = iprefix ? iprefix : cpp_GCC_INCLUDE_DIR;
    1409                 :          0 :   prefix_len = iprefix ? strlen (iprefix) : cpp_GCC_INCLUDE_DIR_len;
    1410                 :            : 
    1411                 :          0 :   path = (char *) xmalloc (prefix_len + suffix_len + 1);
    1412                 :          0 :   memcpy (path, prefix, prefix_len);
    1413                 :          0 :   memcpy (path + prefix_len, suffix, suffix_len);
    1414                 :          0 :   path[prefix_len + suffix_len] = '\0';
    1415                 :            : 
    1416                 :          0 :   add_path (path, chain, 0, false);
    1417                 :          0 : }
    1418                 :            : 
    1419                 :            : /* Handle -D, -U, -A, -imacros, and the first -include.  */
    1420                 :            : static void
    1421                 :     156836 : c_finish_options (void)
    1422                 :            : {
    1423                 :     156836 :   if (!cpp_opts->preprocessed)
    1424                 :            :     {
    1425                 :     156688 :       const line_map_ordinary *bltin_map
    1426                 :     156688 :         = linemap_check_ordinary (linemap_add (line_table, LC_RENAME, 0,
    1427                 :     156688 :                                                _("<built-in>"), 0));
    1428                 :     156688 :       cb_file_change (parse_in, bltin_map);
    1429                 :            : 
    1430                 :            :       /* Make sure all of the builtins about to be declared have
    1431                 :            :          BUILTINS_LOCATION has their location_t.  */
    1432                 :     156688 :       cpp_force_token_locations (parse_in, BUILTINS_LOCATION);
    1433                 :            : 
    1434                 :     156688 :       cpp_init_builtins (parse_in, flag_hosted);
    1435                 :     156688 :       c_cpp_builtins (parse_in);
    1436                 :            : 
    1437                 :            :       /* We're about to send user input to cpplib, so make it warn for
    1438                 :            :          things that we previously (when we sent it internal definitions)
    1439                 :            :          told it to not warn.
    1440                 :            : 
    1441                 :            :          C99 permits implementation-defined characters in identifiers.
    1442                 :            :          The documented meaning of -std= is to turn off extensions that
    1443                 :            :          conflict with the specified standard, and since a strictly
    1444                 :            :          conforming program cannot contain a '$', we do not condition
    1445                 :            :          their acceptance on the -std= setting.  */
    1446                 :     156688 :       cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99);
    1447                 :            : 
    1448                 :     156688 :       const line_map_ordinary *cmd_map
    1449                 :     156688 :         = linemap_check_ordinary (linemap_add (line_table, LC_RENAME, 0,
    1450                 :     156688 :                                                _("<command-line>"), 0));
    1451                 :     156688 :       cb_file_change (parse_in, cmd_map);
    1452                 :            : 
    1453                 :            :       /* All command line defines must have the same location.  */
    1454                 :     156688 :       cpp_force_token_locations (parse_in, cmd_map->start_location);
    1455                 :     294593 :       for (size_t i = 0; i < deferred_count; i++)
    1456                 :            :         {
    1457                 :     137905 :           struct deferred_opt *opt = &deferred_opts[i];
    1458                 :            : 
    1459                 :     137905 :           if (opt->code == OPT_D)
    1460                 :     126611 :             cpp_define (parse_in, opt->arg);
    1461                 :      11294 :           else if (opt->code == OPT_U)
    1462                 :         17 :             cpp_undef (parse_in, opt->arg);
    1463                 :      11277 :           else if (opt->code == OPT_A)
    1464                 :            :             {
    1465                 :         10 :               if (opt->arg[0] == '-')
    1466                 :          2 :                 cpp_unassert (parse_in, opt->arg + 1);
    1467                 :            :               else
    1468                 :          8 :                 cpp_assert (parse_in, opt->arg);
    1469                 :            :             }
    1470                 :            :         }
    1471                 :            : 
    1472                 :     156688 :       cpp_stop_forcing_token_locations (parse_in);
    1473                 :            :     }
    1474                 :        148 :   else if (cpp_opts->directives_only)
    1475                 :          2 :     cpp_init_special_builtins (parse_in);
    1476                 :            : 
    1477                 :            :   /* Start the main input file, if the debug writer wants it. */
    1478                 :     156836 :   if (debug_hooks->start_end_main_source_file
    1479                 :      30620 :       && !flag_preprocess_only)
    1480                 :      30021 :     (*debug_hooks->start_source_file) (0, this_input_filename);
    1481                 :            : 
    1482                 :     156836 :   if (!cpp_opts->preprocessed)
    1483                 :            :     /* Handle -imacros after -D and -U.  */
    1484                 :     294593 :     for (size_t i = 0; i < deferred_count; i++)
    1485                 :            :       {
    1486                 :     137905 :         struct deferred_opt *opt = &deferred_opts[i];
    1487                 :            : 
    1488                 :     137905 :         if (opt->code == OPT_imacros
    1489                 :     137905 :             && cpp_push_include (parse_in, opt->arg))
    1490                 :            :           {
    1491                 :            :             /* Disable push_command_line_include callback for now.  */
    1492                 :         10 :             include_cursor = deferred_count + 1;
    1493                 :         10 :             cpp_scan_nooutput (parse_in);
    1494                 :            :           }
    1495                 :            :       }
    1496                 :            : 
    1497                 :     156836 :   include_cursor = 0;
    1498                 :     156836 :   push_command_line_include ();
    1499                 :     156836 : }
    1500                 :            : 
    1501                 :            : /* Give CPP the next file given by -include, if any.  */
    1502                 :            : static void
    1503                 :     548365 : push_command_line_include (void)
    1504                 :            : {
    1505                 :            :   /* This can happen if disabled by -imacros for example.
    1506                 :            :      Punt so that we don't set "<command-line>" as the filename for
    1507                 :            :      the header.  */
    1508                 :     548365 :   if (include_cursor > deferred_count)
    1509                 :            :     return;
    1510                 :            : 
    1511                 :     313786 :   if (!done_preinclude)
    1512                 :            :     {
    1513                 :     156836 :       done_preinclude = true;
    1514                 :     156836 :       if (flag_hosted && std_inc && !cpp_opts->preprocessed)
    1515                 :            :         {
    1516                 :     156646 :           const char *preinc = targetcm.c_preinclude ();
    1517                 :     156646 :           if (preinc && cpp_push_default_include (parse_in, preinc))
    1518                 :            :             return;
    1519                 :            :         }
    1520                 :            :     }
    1521                 :            : 
    1522                 :     157140 :   pch_cpp_save_state ();
    1523                 :            : 
    1524                 :     294747 :   while (include_cursor < deferred_count)
    1525                 :            :     {
    1526                 :     137911 :       struct deferred_opt *opt = &deferred_opts[include_cursor++];
    1527                 :            : 
    1528                 :     137905 :       if (!cpp_opts->preprocessed && opt->code == OPT_include
    1529                 :     144314 :           && cpp_push_include (parse_in, opt->arg))
    1530                 :            :         return;
    1531                 :            :     }
    1532                 :            : 
    1533                 :     156836 :   if (include_cursor == deferred_count)
    1534                 :            :     {
    1535                 :     156836 :       include_cursor++;
    1536                 :            :       /* -Wunused-macros should only warn about macros defined hereafter.  */
    1537                 :     156836 :       cpp_opts->warn_unused_macros = cpp_warn_unused_macros;
    1538                 :            :       /* Restore the line map back to the main file.  */
    1539                 :     156836 :       if (!cpp_opts->preprocessed)
    1540                 :     156687 :         cpp_change_file (parse_in, LC_RENAME, this_input_filename);
    1541                 :            : 
    1542                 :            :       /* Set this here so the client can change the option if it wishes,
    1543                 :            :          and after stacking the main file so we don't trace the main file.  */
    1544                 :     156836 :       line_table->trace_includes = cpp_opts->print_include_names;
    1545                 :            :     }
    1546                 :            : }
    1547                 :            : 
    1548                 :            : /* File change callback.  Has to handle -include files.  */
    1549                 :            : static void
    1550                 :    6249760 : cb_file_change (cpp_reader * ARG_UNUSED (pfile),
    1551                 :            :                 const line_map_ordinary *new_map)
    1552                 :            : {
    1553                 :    6249760 :   if (flag_preprocess_only)
    1554                 :      54824 :     pp_file_change (new_map);
    1555                 :            :   else
    1556                 :    6194940 :     fe_file_change (new_map);
    1557                 :            : 
    1558                 :    6249760 :   if (new_map 
    1559                 :    6093190 :       && (new_map->reason == LC_ENTER || new_map->reason == LC_RENAME))
    1560                 :            :     {
    1561                 :            :       /* Signal to plugins that a file is included.  This could happen
    1562                 :            :          several times with the same file path, e.g. because of
    1563                 :            :          several '#include' or '#line' directives...  */
    1564                 :    3454190 :       invoke_plugin_callbacks 
    1565                 :    6249760 :         (PLUGIN_INCLUDE_FILE,
    1566                 :    3454190 :          const_cast<char*> (ORDINARY_MAP_FILE_NAME (new_map)));
    1567                 :            :     }
    1568                 :            : 
    1569                 :    6249760 :   if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
    1570                 :            :     {
    1571                 :     391529 :       pch_cpp_save_state ();
    1572                 :     391529 :       push_command_line_include ();
    1573                 :            :     }
    1574                 :    6249760 : }
    1575                 :            : 
    1576                 :            : void
    1577                 :         18 : cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
    1578                 :            : {
    1579                 :         18 :   if (!set_src_pwd (dir))
    1580                 :          0 :     warning (0, "too late for # directive to set debug directory");
    1581                 :         18 : }
    1582                 :            : 
    1583                 :            : /* Set the C 89 standard (with 1994 amendments if C94, without GNU
    1584                 :            :    extensions if ISO).  There is no concept of gnu94.  */
    1585                 :            : static void
    1586                 :       1200 : set_std_c89 (int c94, int iso)
    1587                 :            : {
    1588                 :       1414 :   cpp_set_lang (parse_in, c94 ? CLK_STDC94: iso ? CLK_STDC89: CLK_GNUC89);
    1589                 :       1200 :   flag_iso = iso;
    1590                 :       1200 :   flag_no_asm = iso;
    1591                 :       1200 :   flag_no_gnu_keywords = iso;
    1592                 :       1200 :   flag_no_nonansi_builtin = iso;
    1593                 :       1200 :   flag_isoc94 = c94;
    1594                 :       1200 :   flag_isoc99 = 0;
    1595                 :       1200 :   flag_isoc11 = 0;
    1596                 :       1200 :   flag_isoc2x = 0;
    1597                 :       1200 :   lang_hooks.name = "GNU C89";
    1598                 :       1200 : }
    1599                 :            : 
    1600                 :            : /* Set the C 99 standard (without GNU extensions if ISO).  */
    1601                 :            : static void
    1602                 :       1048 : set_std_c99 (int iso)
    1603                 :            : {
    1604                 :       1556 :   cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
    1605                 :       1048 :   flag_no_asm = iso;
    1606                 :       1048 :   flag_no_nonansi_builtin = iso;
    1607                 :       1048 :   flag_iso = iso;
    1608                 :       1048 :   flag_isoc2x = 0;
    1609                 :       1048 :   flag_isoc11 = 0;
    1610                 :       1048 :   flag_isoc99 = 1;
    1611                 :       1048 :   flag_isoc94 = 1;
    1612                 :       1048 :   lang_hooks.name = "GNU C99";
    1613                 :       1048 : }
    1614                 :            : 
    1615                 :            : /* Set the C 11 standard (without GNU extensions if ISO).  */
    1616                 :            : static void
    1617                 :       3298 : set_std_c11 (int iso)
    1618                 :            : {
    1619                 :       6199 :   cpp_set_lang (parse_in, iso ? CLK_STDC11: CLK_GNUC11);
    1620                 :       3298 :   flag_no_asm = iso;
    1621                 :       3298 :   flag_no_nonansi_builtin = iso;
    1622                 :       3298 :   flag_iso = iso;
    1623                 :       3298 :   flag_isoc2x = 0;
    1624                 :       3298 :   flag_isoc11 = 1;
    1625                 :       3298 :   flag_isoc99 = 1;
    1626                 :       3298 :   flag_isoc94 = 1;
    1627                 :       3298 :   lang_hooks.name = "GNU C11";
    1628                 :       3298 : }
    1629                 :            : 
    1630                 :            : /* Set the C 17 standard (without GNU extensions if ISO).  */
    1631                 :            : static void
    1632                 :      78772 : set_std_c17 (int iso)
    1633                 :            : {
    1634                 :     157539 :   cpp_set_lang (parse_in, iso ? CLK_STDC17: CLK_GNUC17);
    1635                 :      78772 :   flag_no_asm = iso;
    1636                 :      78772 :   flag_no_nonansi_builtin = iso;
    1637                 :      78772 :   flag_iso = iso;
    1638                 :      78772 :   flag_isoc2x = 0;
    1639                 :      78772 :   flag_isoc11 = 1;
    1640                 :      78772 :   flag_isoc99 = 1;
    1641                 :      78772 :   flag_isoc94 = 1;
    1642                 :      78772 :   lang_hooks.name = "GNU C17";
    1643                 :      78772 : }
    1644                 :            : 
    1645                 :            : /* Set the C 2X standard (without GNU extensions if ISO).  */
    1646                 :            : static void
    1647                 :         69 : set_std_c2x (int iso)
    1648                 :            : {
    1649                 :         84 :   cpp_set_lang (parse_in, iso ? CLK_STDC2X: CLK_GNUC2X);
    1650                 :         69 :   flag_no_asm = iso;
    1651                 :         69 :   flag_no_nonansi_builtin = iso;
    1652                 :         69 :   flag_iso = iso;
    1653                 :         69 :   flag_isoc2x = 1;
    1654                 :         69 :   flag_isoc11 = 1;
    1655                 :         69 :   flag_isoc99 = 1;
    1656                 :         69 :   flag_isoc94 = 1;
    1657                 :         69 :   lang_hooks.name = "GNU C2X";
    1658                 :         69 : }
    1659                 :            : 
    1660                 :            : 
    1661                 :            : /* Set the C++ 98 standard (without GNU extensions if ISO).  */
    1662                 :            : static void
    1663                 :      11211 : set_std_cxx98 (int iso)
    1664                 :            : {
    1665                 :      15193 :   cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
    1666                 :      11211 :   flag_no_gnu_keywords = iso;
    1667                 :      11211 :   flag_no_nonansi_builtin = iso;
    1668                 :      11211 :   flag_iso = iso;
    1669                 :      11211 :   flag_isoc94 = 0;
    1670                 :      11211 :   flag_isoc99 = 0;
    1671                 :      11211 :   cxx_dialect = cxx98;
    1672                 :      11211 :   lang_hooks.name = "GNU C++98";
    1673                 :      11211 : }
    1674                 :            : 
    1675                 :            : /* Set the C++ 2011 standard (without GNU extensions if ISO).  */
    1676                 :            : static void
    1677                 :       1492 : set_std_cxx11 (int iso)
    1678                 :            : {
    1679                 :       2315 :   cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11);
    1680                 :       1492 :   flag_no_gnu_keywords = iso;
    1681                 :       1492 :   flag_no_nonansi_builtin = iso;
    1682                 :       1492 :   flag_iso = iso;
    1683                 :            :   /* C++11 includes the C99 standard library.  */
    1684                 :       1492 :   flag_isoc94 = 1;
    1685                 :       1492 :   flag_isoc99 = 1;
    1686                 :       1492 :   cxx_dialect = cxx11;
    1687                 :       1492 :   lang_hooks.name = "GNU C++11";
    1688                 :       1492 : }
    1689                 :            : 
    1690                 :            : /* Set the C++ 2014 standard (without GNU extensions if ISO).  */
    1691                 :            : static void
    1692                 :      92946 : set_std_cxx14 (int iso)
    1693                 :            : {
    1694                 :     175697 :   cpp_set_lang (parse_in, iso ? CLK_CXX14: CLK_GNUCXX14);
    1695                 :      92946 :   flag_no_gnu_keywords = iso;
    1696                 :      92946 :   flag_no_nonansi_builtin = iso;
    1697                 :      92946 :   flag_iso = iso;
    1698                 :            :   /* C++14 includes the C99 standard library.  */
    1699                 :      92946 :   flag_isoc94 = 1;
    1700                 :      92946 :   flag_isoc99 = 1;
    1701                 :      92946 :   cxx_dialect = cxx14;
    1702                 :      92946 :   lang_hooks.name = "GNU C++14";
    1703                 :      92946 : }
    1704                 :            : 
    1705                 :            : /* Set the C++ 2017 standard (without GNU extensions if ISO).  */
    1706                 :            : static void
    1707                 :      16332 : set_std_cxx17 (int iso)
    1708                 :            : {
    1709                 :      21541 :   cpp_set_lang (parse_in, iso ? CLK_CXX17: CLK_GNUCXX17);
    1710                 :      16332 :   flag_no_gnu_keywords = iso;
    1711                 :      16332 :   flag_no_nonansi_builtin = iso;
    1712                 :      16332 :   flag_iso = iso;
    1713                 :            :   /* C++17 includes the C11 standard library.  */
    1714                 :      16332 :   flag_isoc94 = 1;
    1715                 :      16332 :   flag_isoc99 = 1;
    1716                 :      16332 :   flag_isoc11 = 1;
    1717                 :      16332 :   cxx_dialect = cxx17;
    1718                 :      16332 :   lang_hooks.name = "GNU C++17";
    1719                 :      16332 : }
    1720                 :            : 
    1721                 :            : /* Set the C++ 202a draft standard (without GNU extensions if ISO).  */
    1722                 :            : static void
    1723                 :      15860 : set_std_cxx2a (int iso)
    1724                 :            : {
    1725                 :      20927 :   cpp_set_lang (parse_in, iso ? CLK_CXX2A: CLK_GNUCXX2A);
    1726                 :      15860 :   flag_no_gnu_keywords = iso;
    1727                 :      15860 :   flag_no_nonansi_builtin = iso;
    1728                 :      15860 :   flag_iso = iso;
    1729                 :            :   /* C++17 includes the C11 standard library.  */
    1730                 :      15860 :   flag_isoc94 = 1;
    1731                 :      15860 :   flag_isoc99 = 1;
    1732                 :      15860 :   flag_isoc11 = 1;
    1733                 :            :   /* C++2a includes concepts. */
    1734                 :      15860 :   cxx_dialect = cxx2a;
    1735                 :      15860 :   lang_hooks.name = "GNU C++17"; /* Pretend C++17 until standardization.  */
    1736                 :      15860 : }
    1737                 :            : 
    1738                 :            : /* Args to -d specify what to dump.  Silently ignore
    1739                 :            :    unrecognized options; they may be aimed at toplev.c.  */
    1740                 :            : static void
    1741                 :          0 : handle_OPT_d (const char *arg)
    1742                 :            : {
    1743                 :       4122 :   char c;
    1744                 :            : 
    1745                 :       4122 :   while ((c = *arg++) != '\0')
    1746                 :       2061 :     switch (c)
    1747                 :            :       {
    1748                 :       1197 :       case 'M':                 /* Dump macros only.  */
    1749                 :       1197 :       case 'N':                 /* Dump names.  */
    1750                 :       1197 :       case 'D':                 /* Dump definitions.  */
    1751                 :       1197 :       case 'U':                 /* Dump used macros.  */
    1752                 :       1197 :         flag_dump_macros = c;
    1753                 :       1197 :         break;
    1754                 :            : 
    1755                 :          2 :       case 'I':
    1756                 :          2 :         flag_dump_includes = 1;
    1757                 :          2 :         break;
    1758                 :            :       }
    1759                 :          0 : }

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.