LCOV - code coverage report
Current view: top level - gcc - gcc.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2933 3996 73.4 %
Date: 2020-03-28 11:57:23 Functions: 109 138 79.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Compiler driver program that can handle many languages.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : /* This program is the user interface to the C compiler and possibly to
      21                 :            : other compilers.  It is used because compilation is a complicated procedure
      22                 :            : which involves running several programs and passing temporary files between
      23                 :            : them, forwarding the users switches to those programs selectively,
      24                 :            : and deleting the temporary files at the end.
      25                 :            : 
      26                 :            : CC recognizes how to compile each input file by suffixes in the file names.
      27                 :            : Once it knows which kind of compilation to perform, the procedure for
      28                 :            : compilation is specified by a string called a "spec".  */
      29                 :            : 
      30                 :            : #include "config.h"
      31                 :            : #include "system.h"
      32                 :            : #include "coretypes.h"
      33                 :            : #include "multilib.h" /* before tm.h */
      34                 :            : #include "tm.h"
      35                 :            : #include "xregex.h"
      36                 :            : #include "obstack.h"
      37                 :            : #include "intl.h"
      38                 :            : #include "prefix.h"
      39                 :            : #include "opt-suggestions.h"
      40                 :            : #include "gcc.h"
      41                 :            : #include "diagnostic.h"
      42                 :            : #include "flags.h"
      43                 :            : #include "opts.h"
      44                 :            : #include "filenames.h"
      45                 :            : #include "spellcheck.h"
      46                 :            : 
      47                 :            : 
      48                 :            : 
      49                 :            : /* Manage the manipulation of env vars.
      50                 :            : 
      51                 :            :    We poison "getenv" and "putenv", so that all enviroment-handling is
      52                 :            :    done through this class.  Note that poisoning happens in the
      53                 :            :    preprocessor at the identifier level, and doesn't distinguish between
      54                 :            :      env.getenv ();
      55                 :            :    and
      56                 :            :      getenv ();
      57                 :            :    Hence we need to use "get" for the accessor method, not "getenv".  */
      58                 :            : 
      59                 :            : struct env_manager
      60                 :            : {
      61                 :            :  public:
      62                 :            :   void init (bool can_restore, bool debug);
      63                 :            :   const char *get (const char *name);
      64                 :            :   void xput (const char *string);
      65                 :            :   void restore ();
      66                 :            : 
      67                 :            :  private:
      68                 :            :   bool m_can_restore;
      69                 :            :   bool m_debug;
      70                 :            :   struct kv
      71                 :            :   {
      72                 :            :     char *m_key;
      73                 :            :     char *m_value;
      74                 :            :   };
      75                 :            :   vec<kv> m_keys;
      76                 :            : 
      77                 :            : };
      78                 :            : 
      79                 :            : /* The singleton instance of class env_manager.  */
      80                 :            : 
      81                 :            : static env_manager env;
      82                 :            : 
      83                 :            : /* Initializer for class env_manager.
      84                 :            : 
      85                 :            :    We can't do this as a constructor since we have a statically
      86                 :            :    allocated instance ("env" above).  */
      87                 :            : 
      88                 :            : void
      89                 :     203006 : env_manager::init (bool can_restore, bool debug)
      90                 :            : {
      91                 :     203006 :   m_can_restore = can_restore;
      92                 :     203006 :   m_debug = debug;
      93                 :     203006 : }
      94                 :            : 
      95                 :            : /* Get the value of NAME within the environment.  Essentially
      96                 :            :    a wrapper for ::getenv, but adding logging, and the possibility
      97                 :            :    of caching results.  */
      98                 :            : 
      99                 :            : const char *
     100                 :    1191750 : env_manager::get (const char *name)
     101                 :            : {
     102                 :    1191750 :   const char *result = ::getenv (name);
     103                 :    1191750 :   if (m_debug)
     104                 :          0 :     fprintf (stderr, "env_manager::getenv (%s) -> %s\n", name, result);
     105                 :    1191750 :   return result;
     106                 :            : }
     107                 :            : 
     108                 :            : /* Put the given KEY=VALUE entry STRING into the environment.
     109                 :            :    If the env_manager was initialized with CAN_RESTORE set, then
     110                 :            :    also record the old value of KEY within the environment, so that it
     111                 :            :    can be later restored.  */
     112                 :            : 
     113                 :            : void
     114                 :    1390300 : env_manager::xput (const char *string)
     115                 :            : {
     116                 :    1390300 :   if (m_debug)
     117                 :          0 :     fprintf (stderr, "env_manager::xput (%s)\n", string);
     118                 :    1390300 :   if (verbose_flag)
     119                 :       4410 :     fnotice (stderr, "%s\n", string);
     120                 :            : 
     121                 :    1390300 :   if (m_can_restore)
     122                 :            :     {
     123                 :       5966 :       char *equals = strchr (const_cast <char *> (string), '=');
     124                 :       5966 :       gcc_assert (equals);
     125                 :            : 
     126                 :       5966 :       struct kv kv;
     127                 :       5966 :       kv.m_key = xstrndup (string, equals - string);
     128                 :       5966 :       const char *cur_value = ::getenv (kv.m_key);
     129                 :       5966 :       if (m_debug)
     130                 :          0 :         fprintf (stderr, "saving old value: %s\n",cur_value);
     131                 :       5966 :       kv.m_value = cur_value ? xstrdup (cur_value) : NULL;
     132                 :       5966 :       m_keys.safe_push (kv);
     133                 :            :     }
     134                 :            : 
     135                 :    1390300 :   ::putenv (CONST_CAST (char *, string));
     136                 :    1390300 : }
     137                 :            : 
     138                 :            : /* Undo any xputenv changes made since last restore.
     139                 :            :    Can only be called if the env_manager was initialized with
     140                 :            :    CAN_RESTORE enabled.  */
     141                 :            : 
     142                 :            : void
     143                 :        853 : env_manager::restore ()
     144                 :            : {
     145                 :        853 :   unsigned int i;
     146                 :        853 :   struct kv *item;
     147                 :            : 
     148                 :        853 :   gcc_assert (m_can_restore);
     149                 :            : 
     150                 :       7672 :   FOR_EACH_VEC_ELT_REVERSE (m_keys, i, item)
     151                 :            :     {
     152                 :       5966 :       if (m_debug)
     153                 :          0 :         printf ("restoring saved key: %s value: %s\n", item->m_key, item->m_value);
     154                 :       5966 :       if (item->m_value)
     155                 :       3407 :         ::setenv (item->m_key, item->m_value, 1);
     156                 :            :       else
     157                 :       2559 :         ::unsetenv (item->m_key);
     158                 :       5966 :       free (item->m_key);
     159                 :       5966 :       free (item->m_value);
     160                 :            :     }
     161                 :            : 
     162                 :        853 :   m_keys.truncate (0);
     163                 :        853 : }
     164                 :            : 
     165                 :            : /* Forbid other uses of getenv and putenv.  */
     166                 :            : #if (GCC_VERSION >= 3000)
     167                 :            : #pragma GCC poison getenv putenv
     168                 :            : #endif
     169                 :            : 
     170                 :            : 
     171                 :            : 
     172                 :            : /* By default there is no special suffix for target executables.  */
     173                 :            : #ifdef TARGET_EXECUTABLE_SUFFIX
     174                 :            : #define HAVE_TARGET_EXECUTABLE_SUFFIX
     175                 :            : #else
     176                 :            : #define TARGET_EXECUTABLE_SUFFIX ""
     177                 :            : #endif
     178                 :            : 
     179                 :            : /* By default there is no special suffix for host executables.  */
     180                 :            : #ifdef HOST_EXECUTABLE_SUFFIX
     181                 :            : #define HAVE_HOST_EXECUTABLE_SUFFIX
     182                 :            : #else
     183                 :            : #define HOST_EXECUTABLE_SUFFIX ""
     184                 :            : #endif
     185                 :            : 
     186                 :            : /* By default, the suffix for target object files is ".o".  */
     187                 :            : #ifdef TARGET_OBJECT_SUFFIX
     188                 :            : #define HAVE_TARGET_OBJECT_SUFFIX
     189                 :            : #else
     190                 :            : #define TARGET_OBJECT_SUFFIX ".o"
     191                 :            : #endif
     192                 :            : 
     193                 :            : static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
     194                 :            : 
     195                 :            : /* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */
     196                 :            : #ifndef LIBRARY_PATH_ENV
     197                 :            : #define LIBRARY_PATH_ENV "LIBRARY_PATH"
     198                 :            : #endif
     199                 :            : 
     200                 :            : /* If a stage of compilation returns an exit status >= 1,
     201                 :            :    compilation of that file ceases.  */
     202                 :            : 
     203                 :            : #define MIN_FATAL_STATUS 1
     204                 :            : 
     205                 :            : /* Flag set by cppspec.c to 1.  */
     206                 :            : int is_cpp_driver;
     207                 :            : 
     208                 :            : /* Flag set to nonzero if an @file argument has been supplied to gcc.  */
     209                 :            : static bool at_file_supplied;
     210                 :            : 
     211                 :            : /* Definition of string containing the arguments given to configure.  */
     212                 :            : #include "configargs.h"
     213                 :            : 
     214                 :            : /* Flag saying to print the command line options understood by gcc and its
     215                 :            :    sub-processes.  */
     216                 :            : 
     217                 :            : static int print_help_list;
     218                 :            : 
     219                 :            : /* Flag saying to print the version of gcc and its sub-processes.  */
     220                 :            : 
     221                 :            : static int print_version;
     222                 :            : 
     223                 :            : /* Flag that stores string prefix for which we provide bash completion.  */
     224                 :            : 
     225                 :            : static const char *completion = NULL;
     226                 :            : 
     227                 :            : /* Flag indicating whether we should ONLY print the command and
     228                 :            :    arguments (like verbose_flag) without executing the command.
     229                 :            :    Displayed arguments are quoted so that the generated command
     230                 :            :    line is suitable for execution.  This is intended for use in
     231                 :            :    shell scripts to capture the driver-generated command line.  */
     232                 :            : static int verbose_only_flag;
     233                 :            : 
     234                 :            : /* Flag indicating how to print command line options of sub-processes.  */
     235                 :            : 
     236                 :            : static int print_subprocess_help;
     237                 :            : 
     238                 :            : /* Linker suffix passed to -fuse-ld=... */
     239                 :            : static const char *use_ld;
     240                 :            : 
     241                 :            : /* Whether we should report subprocess execution times to a file.  */
     242                 :            : 
     243                 :            : FILE *report_times_to_file = NULL;
     244                 :            : 
     245                 :            : /* Nonzero means place this string before uses of /, so that include
     246                 :            :    and library files can be found in an alternate location.  */
     247                 :            : 
     248                 :            : #ifdef TARGET_SYSTEM_ROOT
     249                 :            : #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
     250                 :            : #else
     251                 :            : #define DEFAULT_TARGET_SYSTEM_ROOT (0)
     252                 :            : #endif
     253                 :            : static const char *target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
     254                 :            : 
     255                 :            : /* Nonzero means pass the updated target_system_root to the compiler.  */
     256                 :            : 
     257                 :            : static int target_system_root_changed;
     258                 :            : 
     259                 :            : /* Nonzero means append this string to target_system_root.  */
     260                 :            : 
     261                 :            : static const char *target_sysroot_suffix = 0;
     262                 :            : 
     263                 :            : /* Nonzero means append this string to target_system_root for headers.  */
     264                 :            : 
     265                 :            : static const char *target_sysroot_hdrs_suffix = 0;
     266                 :            : 
     267                 :            : /* Nonzero means write "temp" files in source directory
     268                 :            :    and use the source file's name in them, and don't delete them.  */
     269                 :            : 
     270                 :            : static enum save_temps {
     271                 :            :   SAVE_TEMPS_NONE,              /* no -save-temps */
     272                 :            :   SAVE_TEMPS_CWD,               /* -save-temps in current directory */
     273                 :            :   SAVE_TEMPS_OBJ                /* -save-temps in object directory */
     274                 :            : } save_temps_flag;
     275                 :            : 
     276                 :            : /* Output file to use to get the object directory for -save-temps=obj  */
     277                 :            : static char *save_temps_prefix = 0;
     278                 :            : static size_t save_temps_length = 0;
     279                 :            : 
     280                 :            : /* The compiler version.  */
     281                 :            : 
     282                 :            : static const char *compiler_version;
     283                 :            : 
     284                 :            : /* The target version.  */
     285                 :            : 
     286                 :            : static const char *const spec_version = DEFAULT_TARGET_VERSION;
     287                 :            : 
     288                 :            : /* The target machine.  */
     289                 :            : 
     290                 :            : static const char *spec_machine = DEFAULT_TARGET_MACHINE;
     291                 :            : static const char *spec_host_machine = DEFAULT_REAL_TARGET_MACHINE;
     292                 :            : 
     293                 :            : /* List of offload targets.  Separated by colon.  Empty string for
     294                 :            :    -foffload=disable.  */
     295                 :            : 
     296                 :            : static char *offload_targets = NULL;
     297                 :            : 
     298                 :            : /* Nonzero if cross-compiling.
     299                 :            :    When -b is used, the value comes from the `specs' file.  */
     300                 :            : 
     301                 :            : #ifdef CROSS_DIRECTORY_STRUCTURE
     302                 :            : static const char *cross_compile = "1";
     303                 :            : #else
     304                 :            : static const char *cross_compile = "0";
     305                 :            : #endif
     306                 :            : 
     307                 :            : /* Greatest exit code of sub-processes that has been encountered up to
     308                 :            :    now.  */
     309                 :            : static int greatest_status = 1;
     310                 :            : 
     311                 :            : /* This is the obstack which we use to allocate many strings.  */
     312                 :            : 
     313                 :            : static struct obstack obstack;
     314                 :            : 
     315                 :            : /* This is the obstack to build an environment variable to pass to
     316                 :            :    collect2 that describes all of the relevant switches of what to
     317                 :            :    pass the compiler in building the list of pointers to constructors
     318                 :            :    and destructors.  */
     319                 :            : 
     320                 :            : static struct obstack collect_obstack;
     321                 :            : 
     322                 :            : /* Forward declaration for prototypes.  */
     323                 :            : struct path_prefix;
     324                 :            : struct prefix_list;
     325                 :            : 
     326                 :            : static void init_spec (void);
     327                 :            : static void store_arg (const char *, int, int);
     328                 :            : static void insert_wrapper (const char *);
     329                 :            : static char *load_specs (const char *);
     330                 :            : static void read_specs (const char *, bool, bool);
     331                 :            : static void set_spec (const char *, const char *, bool);
     332                 :            : static struct compiler *lookup_compiler (const char *, size_t, const char *);
     333                 :            : static char *build_search_list (const struct path_prefix *, const char *,
     334                 :            :                                 bool, bool);
     335                 :            : static void xputenv (const char *);
     336                 :            : static void putenv_from_prefixes (const struct path_prefix *, const char *,
     337                 :            :                                   bool);
     338                 :            : static int access_check (const char *, int);
     339                 :            : static char *find_a_file (const struct path_prefix *, const char *, int, bool);
     340                 :            : static void add_prefix (struct path_prefix *, const char *, const char *,
     341                 :            :                         int, int, int);
     342                 :            : static void add_sysrooted_prefix (struct path_prefix *, const char *,
     343                 :            :                                   const char *, int, int, int);
     344                 :            : static char *skip_whitespace (char *);
     345                 :            : static void delete_if_ordinary (const char *);
     346                 :            : static void delete_temp_files (void);
     347                 :            : static void delete_failure_queue (void);
     348                 :            : static void clear_failure_queue (void);
     349                 :            : static int check_live_switch (int, int);
     350                 :            : static const char *handle_braces (const char *);
     351                 :            : static inline bool input_suffix_matches (const char *, const char *);
     352                 :            : static inline bool switch_matches (const char *, const char *, int);
     353                 :            : static inline void mark_matching_switches (const char *, const char *, int);
     354                 :            : static inline void process_marked_switches (void);
     355                 :            : static const char *process_brace_body (const char *, const char *, const char *, int, int);
     356                 :            : static const struct spec_function *lookup_spec_function (const char *);
     357                 :            : static const char *eval_spec_function (const char *, const char *, const char *);
     358                 :            : static const char *handle_spec_function (const char *, bool *, const char *);
     359                 :            : static char *save_string (const char *, int);
     360                 :            : static void set_collect_gcc_options (void);
     361                 :            : static int do_spec_1 (const char *, int, const char *);
     362                 :            : static int do_spec_2 (const char *, const char *);
     363                 :            : static void do_option_spec (const char *, const char *);
     364                 :            : static void do_self_spec (const char *);
     365                 :            : static const char *find_file (const char *);
     366                 :            : static int is_directory (const char *, bool);
     367                 :            : static const char *validate_switches (const char *, bool);
     368                 :            : static void validate_all_switches (void);
     369                 :            : static inline void validate_switches_from_spec (const char *, bool);
     370                 :            : static void give_switch (int, int);
     371                 :            : static int default_arg (const char *, int);
     372                 :            : static void set_multilib_dir (void);
     373                 :            : static void print_multilib_info (void);
     374                 :            : static void display_help (void);
     375                 :            : static void add_preprocessor_option (const char *, int);
     376                 :            : static void add_assembler_option (const char *, int);
     377                 :            : static void add_linker_option (const char *, int);
     378                 :            : static void process_command (unsigned int, struct cl_decoded_option *);
     379                 :            : static int execute (void);
     380                 :            : static void alloc_args (void);
     381                 :            : static void clear_args (void);
     382                 :            : static void fatal_signal (int);
     383                 :            : #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
     384                 :            : static void init_gcc_specs (struct obstack *, const char *, const char *,
     385                 :            :                             const char *);
     386                 :            : #endif
     387                 :            : #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
     388                 :            : static const char *convert_filename (const char *, int, int);
     389                 :            : #endif
     390                 :            : 
     391                 :            : static void try_generate_repro (const char **argv);
     392                 :            : static const char *getenv_spec_function (int, const char **);
     393                 :            : static const char *if_exists_spec_function (int, const char **);
     394                 :            : static const char *if_exists_else_spec_function (int, const char **);
     395                 :            : static const char *sanitize_spec_function (int, const char **);
     396                 :            : static const char *replace_outfile_spec_function (int, const char **);
     397                 :            : static const char *remove_outfile_spec_function (int, const char **);
     398                 :            : static const char *version_compare_spec_function (int, const char **);
     399                 :            : static const char *include_spec_function (int, const char **);
     400                 :            : static const char *find_file_spec_function (int, const char **);
     401                 :            : static const char *find_plugindir_spec_function (int, const char **);
     402                 :            : static const char *print_asm_header_spec_function (int, const char **);
     403                 :            : static const char *compare_debug_dump_opt_spec_function (int, const char **);
     404                 :            : static const char *compare_debug_self_opt_spec_function (int, const char **);
     405                 :            : static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
     406                 :            : static const char *pass_through_libs_spec_func (int, const char **);
     407                 :            : static const char *replace_extension_spec_func (int, const char **);
     408                 :            : static const char *greater_than_spec_func (int, const char **);
     409                 :            : static const char *debug_level_greater_than_spec_func (int, const char **);
     410                 :            : static const char *find_fortran_preinclude_file (int, const char **);
     411                 :            : static char *convert_white_space (char *);
     412                 :            : 
     413                 :            : /* The Specs Language
     414                 :            : 
     415                 :            : Specs are strings containing lines, each of which (if not blank)
     416                 :            : is made up of a program name, and arguments separated by spaces.
     417                 :            : The program name must be exact and start from root, since no path
     418                 :            : is searched and it is unreliable to depend on the current working directory.
     419                 :            : Redirection of input or output is not supported; the subprograms must
     420                 :            : accept filenames saying what files to read and write.
     421                 :            : 
     422                 :            : In addition, the specs can contain %-sequences to substitute variable text
     423                 :            : or for conditional text.  Here is a table of all defined %-sequences.
     424                 :            : Note that spaces are not generated automatically around the results of
     425                 :            : expanding these sequences; therefore, you can concatenate them together
     426                 :            : or with constant text in a single argument.
     427                 :            : 
     428                 :            :  %%     substitute one % into the program name or argument.
     429                 :            :  %i     substitute the name of the input file being processed.
     430                 :            :  %b     substitute the basename of the input file being processed.
     431                 :            :         This is the substring up to (and not including) the last period
     432                 :            :         and not including the directory unless -save-temps was specified
     433                 :            :         to put temporaries in a different location.
     434                 :            :  %B     same as %b, but include the file suffix (text after the last period).
     435                 :            :  %gSUFFIX
     436                 :            :         substitute a file name that has suffix SUFFIX and is chosen
     437                 :            :         once per compilation, and mark the argument a la %d.  To reduce
     438                 :            :         exposure to denial-of-service attacks, the file name is now
     439                 :            :         chosen in a way that is hard to predict even when previously
     440                 :            :         chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
     441                 :            :         might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
     442                 :            :         the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
     443                 :            :         had been pre-processed.  Previously, %g was simply substituted
     444                 :            :         with a file name chosen once per compilation, without regard
     445                 :            :         to any appended suffix (which was therefore treated just like
     446                 :            :         ordinary text), making such attacks more likely to succeed.
     447                 :            :  %|SUFFIX
     448                 :            :         like %g, but if -pipe is in effect, expands simply to "-".
     449                 :            :  %mSUFFIX
     450                 :            :         like %g, but if -pipe is in effect, expands to nothing.  (We have both
     451                 :            :         %| and %m to accommodate differences between system assemblers; see
     452                 :            :         the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
     453                 :            :  %uSUFFIX
     454                 :            :         like %g, but generates a new temporary file name even if %uSUFFIX
     455                 :            :         was already seen.
     456                 :            :  %USUFFIX
     457                 :            :         substitutes the last file name generated with %uSUFFIX, generating a
     458                 :            :         new one if there is no such last file name.  In the absence of any
     459                 :            :         %uSUFFIX, this is just like %gSUFFIX, except they don't share
     460                 :            :         the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
     461                 :            :         would involve the generation of two distinct file names, one
     462                 :            :         for each `%g.s' and another for each `%U.s'.  Previously, %U was
     463                 :            :         simply substituted with a file name chosen for the previous %u,
     464                 :            :         without regard to any appended suffix.
     465                 :            :  %jSUFFIX
     466                 :            :         substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
     467                 :            :         writable, and if save-temps is off; otherwise, substitute the name
     468                 :            :         of a temporary file, just like %u.  This temporary file is not
     469                 :            :         meant for communication between processes, but rather as a junk
     470                 :            :         disposal mechanism.
     471                 :            :  %.SUFFIX
     472                 :            :         substitutes .SUFFIX for the suffixes of a matched switch's args when
     473                 :            :         it is subsequently output with %*. SUFFIX is terminated by the next
     474                 :            :         space or %.
     475                 :            :  %d     marks the argument containing or following the %d as a
     476                 :            :         temporary file name, so that file will be deleted if GCC exits
     477                 :            :         successfully.  Unlike %g, this contributes no text to the argument.
     478                 :            :  %w     marks the argument containing or following the %w as the
     479                 :            :         "output file" of this compilation.  This puts the argument
     480                 :            :         into the sequence of arguments that %o will substitute later.
     481                 :            :  %V     indicates that this compilation produces no "output file".
     482                 :            :  %W{...}
     483                 :            :         like %{...} but marks the last argument supplied within as a file
     484                 :            :         to be deleted on failure.
     485                 :            :  %@{...}
     486                 :            :         like %{...} but puts the result into a FILE and substitutes @FILE
     487                 :            :         if an @file argument has been supplied.
     488                 :            :  %o     substitutes the names of all the output files, with spaces
     489                 :            :         automatically placed around them.  You should write spaces
     490                 :            :         around the %o as well or the results are undefined.
     491                 :            :         %o is for use in the specs for running the linker.
     492                 :            :         Input files whose names have no recognized suffix are not compiled
     493                 :            :         at all, but they are included among the output files, so they will
     494                 :            :         be linked.
     495                 :            :  %O     substitutes the suffix for object files.  Note that this is
     496                 :            :         handled specially when it immediately follows %g, %u, or %U
     497                 :            :         (with or without a suffix argument) because of the need for
     498                 :            :         those to form complete file names.  The handling is such that
     499                 :            :         %O is treated exactly as if it had already been substituted,
     500                 :            :         except that %g, %u, and %U do not currently support additional
     501                 :            :         SUFFIX characters following %O as they would following, for
     502                 :            :         example, `.o'.
     503                 :            :  %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
     504                 :            :         (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
     505                 :            :         and -B options) and -imultilib as necessary.
     506                 :            :  %s     current argument is the name of a library or startup file of some sort.
     507                 :            :         Search for that file in a standard list of directories
     508                 :            :         and substitute the full name found.
     509                 :            :  %eSTR  Print STR as an error message.  STR is terminated by a newline.
     510                 :            :         Use this when inconsistent options are detected.
     511                 :            :  %nSTR  Print STR as a notice.  STR is terminated by a newline.
     512                 :            :  %x{OPTION}     Accumulate an option for %X.
     513                 :            :  %X     Output the accumulated linker options specified by compilations.
     514                 :            :  %Y     Output the accumulated assembler options specified by compilations.
     515                 :            :  %Z     Output the accumulated preprocessor options specified by compilations.
     516                 :            :  %a     process ASM_SPEC as a spec.
     517                 :            :         This allows config.h to specify part of the spec for running as.
     518                 :            :  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
     519                 :            :         used here.  This can be used to run a post-processor after the
     520                 :            :         assembler has done its job.
     521                 :            :  %D     Dump out a -L option for each directory in startfile_prefixes.
     522                 :            :         If multilib_dir is set, extra entries are generated with it affixed.
     523                 :            :  %l     process LINK_SPEC as a spec.
     524                 :            :  %L     process LIB_SPEC as a spec.
     525                 :            :  %M     Output multilib_os_dir.
     526                 :            :  %G     process LIBGCC_SPEC as a spec.
     527                 :            :  %R     Output the concatenation of target_system_root and
     528                 :            :         target_sysroot_suffix.
     529                 :            :  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
     530                 :            :  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
     531                 :            :  %C     process CPP_SPEC as a spec.
     532                 :            :  %1     process CC1_SPEC as a spec.
     533                 :            :  %2     process CC1PLUS_SPEC as a spec.
     534                 :            :  %*     substitute the variable part of a matched option.  (See below.)
     535                 :            :         Note that each comma in the substituted string is replaced by
     536                 :            :         a single space.  A space is appended after the last substition
     537                 :            :         unless there is more text in current sequence.
     538                 :            :  %<S    remove all occurrences of -S from the command line.
     539                 :            :         Note - this command is position dependent.  % commands in the
     540                 :            :         spec string before this one will see -S, % commands in the
     541                 :            :         spec string after this one will not.
     542                 :            :  %>S Similar to "%<S", but keep it in the GCC command line.
     543                 :            :  %<S*        remove all occurrences of all switches beginning with -S from the
     544                 :            :         command line.
     545                 :            :  %:function(args)
     546                 :            :         Call the named function FUNCTION, passing it ARGS.  ARGS is
     547                 :            :         first processed as a nested spec string, then split into an
     548                 :            :         argument vector in the usual fashion.  The function returns
     549                 :            :         a string which is processed as if it had appeared literally
     550                 :            :         as part of the current spec.
     551                 :            :  %{S}   substitutes the -S switch, if that switch was given to GCC.
     552                 :            :         If that switch was not specified, this substitutes nothing.
     553                 :            :         Here S is a metasyntactic variable.
     554                 :            :  %{S*}  substitutes all the switches specified to GCC whose names start
     555                 :            :         with -S.  This is used for -o, -I, etc; switches that take
     556                 :            :         arguments.  GCC considers `-o foo' as being one switch whose
     557                 :            :         name starts with `o'.  %{o*} would substitute this text,
     558                 :            :         including the space; thus, two arguments would be generated.
     559                 :            :  %{S*&T*} likewise, but preserve order of S and T options (the order
     560                 :            :         of S and T in the spec is not significant).  Can be any number
     561                 :            :         of ampersand-separated variables; for each the wild card is
     562                 :            :         optional.  Useful for CPP as %{D*&U*&A*}.
     563                 :            : 
     564                 :            :  %{S:X}   substitutes X, if the -S switch was given to GCC.
     565                 :            :  %{!S:X}  substitutes X, if the -S switch was NOT given to GCC.
     566                 :            :  %{S*:X}  substitutes X if one or more switches whose names start
     567                 :            :           with -S was given to GCC.  Normally X is substituted only
     568                 :            :           once, no matter how many such switches appeared.  However,
     569                 :            :           if %* appears somewhere in X, then X will be substituted
     570                 :            :           once for each matching switch, with the %* replaced by the
     571                 :            :           part of that switch that matched the '*'.  A space will be
     572                 :            :           appended after the last substition unless there is more
     573                 :            :           text in current sequence.
     574                 :            :  %{.S:X}  substitutes X, if processing a file with suffix S.
     575                 :            :  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
     576                 :            :  %{,S:X}  substitutes X, if processing a file which will use spec S.
     577                 :            :  %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
     578                 :            : 
     579                 :            :  %{S|T:X} substitutes X if either -S or -T was given to GCC.  This may be
     580                 :            :           combined with '!', '.', ',', and '*' as above binding stronger
     581                 :            :           than the OR.
     582                 :            :           If %* appears in X, all of the alternatives must be starred, and
     583                 :            :           only the first matching alternative is substituted.
     584                 :            :  %{%:function(args):X}
     585                 :            :           Call function named FUNCTION with args ARGS.  If the function
     586                 :            :           returns non-NULL, then X is substituted, if it returns
     587                 :            :           NULL, it isn't substituted.
     588                 :            :  %{S:X;   if S was given to GCC, substitutes X;
     589                 :            :    T:Y;   else if T was given to GCC, substitutes Y;
     590                 :            :     :D}   else substitutes D.  There can be as many clauses as you need.
     591                 :            :           This may be combined with '.', '!', ',', '|', and '*' as above.
     592                 :            : 
     593                 :            :  %(Spec) processes a specification defined in a specs file as *Spec:
     594                 :            : 
     595                 :            : The switch matching text S in a %{S}, %{S:X}, or similar construct can use
     596                 :            : a backslash to ignore the special meaning of the character following it,
     597                 :            : thus allowing literal matching of a character that is otherwise specially
     598                 :            : treated.  For example, %{std=iso9899\:1999:X} substitutes X if the
     599                 :            : -std=iso9899:1999 option is given.
     600                 :            : 
     601                 :            : The conditional text X in a %{S:X} or similar construct may contain
     602                 :            : other nested % constructs or spaces, or even newlines.  They are
     603                 :            : processed as usual, as described above.  Trailing white space in X is
     604                 :            : ignored.  White space may also appear anywhere on the left side of the
     605                 :            : colon in these constructs, except between . or * and the corresponding
     606                 :            : word.
     607                 :            : 
     608                 :            : The -O, -f, -g, -m, and -W switches are handled specifically in these
     609                 :            : constructs.  If another value of -O or the negated form of a -f, -m, or
     610                 :            : -W switch is found later in the command line, the earlier switch
     611                 :            : value is ignored, except with {S*} where S is just one letter; this
     612                 :            : passes all matching options.
     613                 :            : 
     614                 :            : The character | at the beginning of the predicate text is used to indicate
     615                 :            : that a command should be piped to the following command, but only if -pipe
     616                 :            : is specified.
     617                 :            : 
     618                 :            : Note that it is built into GCC which switches take arguments and which
     619                 :            : do not.  You might think it would be useful to generalize this to
     620                 :            : allow each compiler's spec to say which switches take arguments.  But
     621                 :            : this cannot be done in a consistent fashion.  GCC cannot even decide
     622                 :            : which input files have been specified without knowing which switches
     623                 :            : take arguments, and it must know which input files to compile in order
     624                 :            : to tell which compilers to run.
     625                 :            : 
     626                 :            : GCC also knows implicitly that arguments starting in `-l' are to be
     627                 :            : treated as compiler output files, and passed to the linker in their
     628                 :            : proper position among the other output files.  */
     629                 :            : 
     630                 :            : /* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
     631                 :            : 
     632                 :            : /* config.h can define ASM_SPEC to provide extra args to the assembler
     633                 :            :    or extra switch-translations.  */
     634                 :            : #ifndef ASM_SPEC
     635                 :            : #define ASM_SPEC ""
     636                 :            : #endif
     637                 :            : 
     638                 :            : /* config.h can define ASM_FINAL_SPEC to run a post processor after
     639                 :            :    the assembler has run.  */
     640                 :            : #ifndef ASM_FINAL_SPEC
     641                 :            : #define ASM_FINAL_SPEC \
     642                 :            :   "%{gsplit-dwarf: \n\
     643                 :            :        objcopy --extract-dwo \
     644                 :            :          %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
     645                 :            :          %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
     646                 :            :        objcopy --strip-dwo \
     647                 :            :          %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
     648                 :            :     }"
     649                 :            : #endif
     650                 :            : 
     651                 :            : /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
     652                 :            :    or extra switch-translations.  */
     653                 :            : #ifndef CPP_SPEC
     654                 :            : #define CPP_SPEC ""
     655                 :            : #endif
     656                 :            : 
     657                 :            : /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
     658                 :            :    or extra switch-translations.  */
     659                 :            : #ifndef CC1_SPEC
     660                 :            : #define CC1_SPEC ""
     661                 :            : #endif
     662                 :            : 
     663                 :            : /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
     664                 :            :    or extra switch-translations.  */
     665                 :            : #ifndef CC1PLUS_SPEC
     666                 :            : #define CC1PLUS_SPEC ""
     667                 :            : #endif
     668                 :            : 
     669                 :            : /* config.h can define LINK_SPEC to provide extra args to the linker
     670                 :            :    or extra switch-translations.  */
     671                 :            : #ifndef LINK_SPEC
     672                 :            : #define LINK_SPEC ""
     673                 :            : #endif
     674                 :            : 
     675                 :            : /* config.h can define LIB_SPEC to override the default libraries.  */
     676                 :            : #ifndef LIB_SPEC
     677                 :            : #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
     678                 :            : #endif
     679                 :            : 
     680                 :            : /* When using -fsplit-stack we need to wrap pthread_create, in order
     681                 :            :    to initialize the stack guard.  We always use wrapping, rather than
     682                 :            :    shared library ordering, and we keep the wrapper function in
     683                 :            :    libgcc.  This is not yet a real spec, though it could become one;
     684                 :            :    it is currently just stuffed into LINK_SPEC.  FIXME: This wrapping
     685                 :            :    only works with GNU ld and gold.  */
     686                 :            : #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
     687                 :            : #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
     688                 :            : #else
     689                 :            : #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
     690                 :            : #endif
     691                 :            : 
     692                 :            : #ifndef LIBASAN_SPEC
     693                 :            : #define STATIC_LIBASAN_LIBS \
     694                 :            :   " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
     695                 :            : #ifdef LIBASAN_EARLY_SPEC
     696                 :            : #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
     697                 :            : #elif defined(HAVE_LD_STATIC_DYNAMIC)
     698                 :            : #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
     699                 :            :                      "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
     700                 :            :                      STATIC_LIBASAN_LIBS
     701                 :            : #else
     702                 :            : #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
     703                 :            : #endif
     704                 :            : #endif
     705                 :            : 
     706                 :            : #ifndef LIBASAN_EARLY_SPEC
     707                 :            : #define LIBASAN_EARLY_SPEC ""
     708                 :            : #endif
     709                 :            : 
     710                 :            : #ifndef LIBTSAN_SPEC
     711                 :            : #define STATIC_LIBTSAN_LIBS \
     712                 :            :   " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
     713                 :            : #ifdef LIBTSAN_EARLY_SPEC
     714                 :            : #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
     715                 :            : #elif defined(HAVE_LD_STATIC_DYNAMIC)
     716                 :            : #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
     717                 :            :                      "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
     718                 :            :                      STATIC_LIBTSAN_LIBS
     719                 :            : #else
     720                 :            : #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
     721                 :            : #endif
     722                 :            : #endif
     723                 :            : 
     724                 :            : #ifndef LIBTSAN_EARLY_SPEC
     725                 :            : #define LIBTSAN_EARLY_SPEC ""
     726                 :            : #endif
     727                 :            : 
     728                 :            : #ifndef LIBLSAN_SPEC
     729                 :            : #define STATIC_LIBLSAN_LIBS \
     730                 :            :   " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
     731                 :            : #ifdef LIBLSAN_EARLY_SPEC
     732                 :            : #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
     733                 :            : #elif defined(HAVE_LD_STATIC_DYNAMIC)
     734                 :            : #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
     735                 :            :                      "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
     736                 :            :                      STATIC_LIBLSAN_LIBS
     737                 :            : #else
     738                 :            : #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
     739                 :            : #endif
     740                 :            : #endif
     741                 :            : 
     742                 :            : #ifndef LIBLSAN_EARLY_SPEC
     743                 :            : #define LIBLSAN_EARLY_SPEC ""
     744                 :            : #endif
     745                 :            : 
     746                 :            : #ifndef LIBUBSAN_SPEC
     747                 :            : #define STATIC_LIBUBSAN_LIBS \
     748                 :            :   " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
     749                 :            : #ifdef HAVE_LD_STATIC_DYNAMIC
     750                 :            : #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
     751                 :            :                      "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
     752                 :            :                      STATIC_LIBUBSAN_LIBS
     753                 :            : #else
     754                 :            : #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
     755                 :            : #endif
     756                 :            : #endif
     757                 :            : 
     758                 :            : /* Linker options for compressed debug sections.  */
     759                 :            : #if HAVE_LD_COMPRESS_DEBUG == 0
     760                 :            : /* No linker support.  */
     761                 :            : #define LINK_COMPRESS_DEBUG_SPEC \
     762                 :            :         " %{gz*:%e-gz is not supported in this configuration} "
     763                 :            : #elif HAVE_LD_COMPRESS_DEBUG == 1
     764                 :            : /* GNU style on input, GNU ld options.  Reject, not useful.  */
     765                 :            : #define LINK_COMPRESS_DEBUG_SPEC \
     766                 :            :         " %{gz*:%e-gz is not supported in this configuration} "
     767                 :            : #elif HAVE_LD_COMPRESS_DEBUG == 2
     768                 :            : /* GNU style, GNU gold options.  */
     769                 :            : #define LINK_COMPRESS_DEBUG_SPEC \
     770                 :            :         " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
     771                 :            :         " %{gz=none:"        LD_COMPRESS_DEBUG_OPTION "=none}" \
     772                 :            :         " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
     773                 :            : #elif HAVE_LD_COMPRESS_DEBUG == 3
     774                 :            : /* ELF gABI style.  */
     775                 :            : #define LINK_COMPRESS_DEBUG_SPEC \
     776                 :            :         " %{gz|gz=zlib:"  LD_COMPRESS_DEBUG_OPTION "=zlib}" \
     777                 :            :         " %{gz=none:"   LD_COMPRESS_DEBUG_OPTION "=none}" \
     778                 :            :         " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
     779                 :            : #else
     780                 :            : #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
     781                 :            : #endif
     782                 :            : 
     783                 :            : /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
     784                 :            :    included.  */
     785                 :            : #ifndef LIBGCC_SPEC
     786                 :            : #if defined(REAL_LIBGCC_SPEC)
     787                 :            : #define LIBGCC_SPEC REAL_LIBGCC_SPEC
     788                 :            : #elif defined(LINK_LIBGCC_SPECIAL_1)
     789                 :            : /* Have gcc do the search for libgcc.a.  */
     790                 :            : #define LIBGCC_SPEC "libgcc.a%s"
     791                 :            : #else
     792                 :            : #define LIBGCC_SPEC "-lgcc"
     793                 :            : #endif
     794                 :            : #endif
     795                 :            : 
     796                 :            : /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
     797                 :            : #ifndef STARTFILE_SPEC
     798                 :            : #define STARTFILE_SPEC  \
     799                 :            :   "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
     800                 :            : #endif
     801                 :            : 
     802                 :            : /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
     803                 :            : #ifndef ENDFILE_SPEC
     804                 :            : #define ENDFILE_SPEC ""
     805                 :            : #endif
     806                 :            : 
     807                 :            : #ifndef LINKER_NAME
     808                 :            : #define LINKER_NAME "collect2"
     809                 :            : #endif
     810                 :            : 
     811                 :            : #ifdef HAVE_AS_DEBUG_PREFIX_MAP
     812                 :            : #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
     813                 :            : #else
     814                 :            : #define ASM_MAP ""
     815                 :            : #endif
     816                 :            : 
     817                 :            : /* Assembler options for compressed debug sections.  */
     818                 :            : #if HAVE_LD_COMPRESS_DEBUG < 2
     819                 :            : /* Reject if the linker cannot write compressed debug sections.  */
     820                 :            : #define ASM_COMPRESS_DEBUG_SPEC \
     821                 :            :         " %{gz*:%e-gz is not supported in this configuration} "
     822                 :            : #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
     823                 :            : #if HAVE_AS_COMPRESS_DEBUG == 0
     824                 :            : /* No assembler support.  Ignore silently.  */
     825                 :            : #define ASM_COMPRESS_DEBUG_SPEC \
     826                 :            :         " %{gz*:} "
     827                 :            : #elif HAVE_AS_COMPRESS_DEBUG == 1
     828                 :            : /* GNU style, GNU as options.  */
     829                 :            : #define ASM_COMPRESS_DEBUG_SPEC \
     830                 :            :         " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
     831                 :            :         " %{gz=none:"        AS_NO_COMPRESS_DEBUG_OPTION "}" \
     832                 :            :         " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
     833                 :            : #elif HAVE_AS_COMPRESS_DEBUG == 2
     834                 :            : /* ELF gABI style.  */
     835                 :            : #define ASM_COMPRESS_DEBUG_SPEC \
     836                 :            :         " %{gz|gz=zlib:"  AS_COMPRESS_DEBUG_OPTION "=zlib}" \
     837                 :            :         " %{gz=none:"   AS_COMPRESS_DEBUG_OPTION "=none}" \
     838                 :            :         " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
     839                 :            : #else
     840                 :            : #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
     841                 :            : #endif
     842                 :            : #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
     843                 :            : 
     844                 :            : /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
     845                 :            :    to the assembler.  */
     846                 :            : #ifndef ASM_DEBUG_SPEC
     847                 :            : # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
     848                 :            :      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
     849                 :            : #  define ASM_DEBUG_SPEC                                                \
     850                 :            :       (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                            \
     851                 :            :        ? "%{%:debug-level-gt(0):"                                     \
     852                 :            :          "%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP    \
     853                 :            :        : "%{%:debug-level-gt(0):"                                     \
     854                 :            :          "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
     855                 :            : # else
     856                 :            : #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
     857                 :            : #   define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gstabs}}" ASM_MAP
     858                 :            : #  endif
     859                 :            : #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
     860                 :            : #   define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gdwarf2}}" ASM_MAP
     861                 :            : #  endif
     862                 :            : # endif
     863                 :            : #endif
     864                 :            : #ifndef ASM_DEBUG_SPEC
     865                 :            : # define ASM_DEBUG_SPEC ""
     866                 :            : #endif
     867                 :            : 
     868                 :            : /* Here is the spec for running the linker, after compiling all files.  */
     869                 :            : 
     870                 :            : /* This is overridable by the target in case they need to specify the
     871                 :            :    -lgcc and -lc order specially, yet not require them to override all
     872                 :            :    of LINK_COMMAND_SPEC.  */
     873                 :            : #ifndef LINK_GCC_C_SEQUENCE_SPEC
     874                 :            : #define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
     875                 :            : #endif
     876                 :            : 
     877                 :            : #ifndef LINK_SSP_SPEC
     878                 :            : #ifdef TARGET_LIBC_PROVIDES_SSP
     879                 :            : #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
     880                 :            :                        "|fstack-protector-strong|fstack-protector-explicit:}"
     881                 :            : #else
     882                 :            : #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
     883                 :            :                        "|fstack-protector-strong|fstack-protector-explicit" \
     884                 :            :                        ":-lssp_nonshared -lssp}"
     885                 :            : #endif
     886                 :            : #endif
     887                 :            : 
     888                 :            : #ifdef ENABLE_DEFAULT_PIE
     889                 :            : #define PIE_SPEC                "!no-pie"
     890                 :            : #define NO_FPIE1_SPEC           "fno-pie"
     891                 :            : #define FPIE1_SPEC              NO_FPIE1_SPEC ":;"
     892                 :            : #define NO_FPIE2_SPEC           "fno-PIE"
     893                 :            : #define FPIE2_SPEC              NO_FPIE2_SPEC ":;"
     894                 :            : #define NO_FPIE_SPEC            NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
     895                 :            : #define FPIE_SPEC               NO_FPIE_SPEC ":;"
     896                 :            : #define NO_FPIC1_SPEC           "fno-pic"
     897                 :            : #define FPIC1_SPEC              NO_FPIC1_SPEC ":;"
     898                 :            : #define NO_FPIC2_SPEC           "fno-PIC"
     899                 :            : #define FPIC2_SPEC              NO_FPIC2_SPEC ":;"
     900                 :            : #define NO_FPIC_SPEC            NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
     901                 :            : #define FPIC_SPEC               NO_FPIC_SPEC ":;"
     902                 :            : #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
     903                 :            : #define FPIE1_OR_FPIC1_SPEC     NO_FPIE1_AND_FPIC1_SPEC ":;"
     904                 :            : #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
     905                 :            : #define FPIE2_OR_FPIC2_SPEC     NO_FPIE2_AND_FPIC2_SPEC ":;"
     906                 :            : #define NO_FPIE_AND_FPIC_SPEC   NO_FPIE_SPEC "|" NO_FPIC_SPEC
     907                 :            : #define FPIE_OR_FPIC_SPEC       NO_FPIE_AND_FPIC_SPEC ":;"
     908                 :            : #else
     909                 :            : #define PIE_SPEC                "pie"
     910                 :            : #define FPIE1_SPEC              "fpie"
     911                 :            : #define NO_FPIE1_SPEC           FPIE1_SPEC ":;"
     912                 :            : #define FPIE2_SPEC              "fPIE"
     913                 :            : #define NO_FPIE2_SPEC           FPIE2_SPEC ":;"
     914                 :            : #define FPIE_SPEC               FPIE1_SPEC "|" FPIE2_SPEC
     915                 :            : #define NO_FPIE_SPEC            FPIE_SPEC ":;"
     916                 :            : #define FPIC1_SPEC              "fpic"
     917                 :            : #define NO_FPIC1_SPEC           FPIC1_SPEC ":;"
     918                 :            : #define FPIC2_SPEC              "fPIC"
     919                 :            : #define NO_FPIC2_SPEC           FPIC2_SPEC ":;"
     920                 :            : #define FPIC_SPEC               FPIC1_SPEC "|" FPIC2_SPEC
     921                 :            : #define NO_FPIC_SPEC            FPIC_SPEC ":;"
     922                 :            : #define FPIE1_OR_FPIC1_SPEC     FPIE1_SPEC "|" FPIC1_SPEC
     923                 :            : #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
     924                 :            : #define FPIE2_OR_FPIC2_SPEC     FPIE2_SPEC "|" FPIC2_SPEC
     925                 :            : #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
     926                 :            : #define FPIE_OR_FPIC_SPEC       FPIE_SPEC "|" FPIC_SPEC
     927                 :            : #define NO_FPIE_AND_FPIC_SPEC   FPIE_OR_FPIC_SPEC ":;"
     928                 :            : #endif
     929                 :            : 
     930                 :            : #ifndef LINK_PIE_SPEC
     931                 :            : #ifdef HAVE_LD_PIE
     932                 :            : #ifndef LD_PIE_SPEC
     933                 :            : #define LD_PIE_SPEC "-pie"
     934                 :            : #endif
     935                 :            : #else
     936                 :            : #define LD_PIE_SPEC ""
     937                 :            : #endif
     938                 :            : #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
     939                 :            : #endif
     940                 :            : 
     941                 :            : #ifndef LINK_BUILDID_SPEC
     942                 :            : # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
     943                 :            : #  define LINK_BUILDID_SPEC "%{!r:--build-id} "
     944                 :            : # endif
     945                 :            : #endif
     946                 :            : 
     947                 :            : /* Conditional to test whether the LTO plugin is used or not.
     948                 :            :    FIXME: For slim LTO we will need to enable plugin unconditionally.  This
     949                 :            :    still cause problems with PLUGIN_LD != LD and when plugin is built but
     950                 :            :    not useable.  For GCC 4.6 we don't support slim LTO and thus we can enable
     951                 :            :    plugin only when LTO is enabled.  We still honor explicit
     952                 :            :    -fuse-linker-plugin if the linker used understands -plugin.  */
     953                 :            : 
     954                 :            : /* The linker has some plugin support.  */
     955                 :            : #if HAVE_LTO_PLUGIN > 0
     956                 :            : /* The linker used has full plugin support, use LTO plugin by default.  */
     957                 :            : #if HAVE_LTO_PLUGIN == 2
     958                 :            : #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
     959                 :            : #define PLUGIN_COND_CLOSE "}"
     960                 :            : #else
     961                 :            : /* The linker used has limited plugin support, use LTO plugin with explicit
     962                 :            :    -fuse-linker-plugin.  */
     963                 :            : #define PLUGIN_COND "fuse-linker-plugin"
     964                 :            : #define PLUGIN_COND_CLOSE ""
     965                 :            : #endif
     966                 :            : #define LINK_PLUGIN_SPEC \
     967                 :            :     "%{" PLUGIN_COND": \
     968                 :            :     -plugin %(linker_plugin_file) \
     969                 :            :     -plugin-opt=%(lto_wrapper) \
     970                 :            :     -plugin-opt=-fresolution=%u.res \
     971                 :            :     %{flinker-output=*:-plugin-opt=-linker-output-known} \
     972                 :            :     %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
     973                 :            :     }" PLUGIN_COND_CLOSE
     974                 :            : #else
     975                 :            : /* The linker used doesn't support -plugin, reject -fuse-linker-plugin.  */
     976                 :            : #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
     977                 :            :     %e-fuse-linker-plugin is not supported in this configuration}"
     978                 :            : #endif
     979                 :            : 
     980                 :            : /* Linker command line options for -fsanitize= early on the command line.  */
     981                 :            : #ifndef SANITIZER_EARLY_SPEC
     982                 :            : #define SANITIZER_EARLY_SPEC "\
     983                 :            : %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
     984                 :            :     %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
     985                 :            :     %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
     986                 :            : #endif
     987                 :            : 
     988                 :            : /* Linker command line options for -fsanitize= late on the command line.  */
     989                 :            : #ifndef SANITIZER_SPEC
     990                 :            : #define SANITIZER_SPEC "\
     991                 :            : %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
     992                 :            :     %{static:%ecannot specify -static with -fsanitize=address}}\
     993                 :            :     %{%:sanitize(thread):" LIBTSAN_SPEC "\
     994                 :            :     %{static:%ecannot specify -static with -fsanitize=thread}}\
     995                 :            :     %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
     996                 :            :     %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
     997                 :            : #endif
     998                 :            : 
     999                 :            : #ifndef POST_LINK_SPEC
    1000                 :            : #define POST_LINK_SPEC ""
    1001                 :            : #endif
    1002                 :            : 
    1003                 :            : /*  This is the spec to use, once the code for creating the vtable
    1004                 :            :     verification runtime library, libvtv.so, has been created.  Currently
    1005                 :            :     the vtable verification runtime functions are in libstdc++, so we use
    1006                 :            :     the spec just below this one.  */
    1007                 :            : #ifndef VTABLE_VERIFICATION_SPEC
    1008                 :            : #if ENABLE_VTABLE_VERIFY
    1009                 :            : #define VTABLE_VERIFICATION_SPEC "\
    1010                 :            : %{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
    1011                 :            :     %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
    1012                 :            : #else
    1013                 :            : #define VTABLE_VERIFICATION_SPEC "\
    1014                 :            : %{fvtable-verify=none:} \
    1015                 :            : %{fvtable-verify=std: \
    1016                 :            :   %e-fvtable-verify=std is not supported in this configuration} \
    1017                 :            : %{fvtable-verify=preinit: \
    1018                 :            :   %e-fvtable-verify=preinit is not supported in this configuration}"
    1019                 :            : #endif
    1020                 :            : #endif
    1021                 :            : 
    1022                 :            : /* -u* was put back because both BSD and SysV seem to support it.  */
    1023                 :            : /* %{static|no-pie|static-pie:} simply prevents an error message:
    1024                 :            :    1. If the target machine doesn't handle -static.
    1025                 :            :    2. If PIE isn't enabled by default.
    1026                 :            :    3. If the target machine doesn't handle -static-pie.
    1027                 :            :  */
    1028                 :            : /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
    1029                 :            :    scripts which exist in user specified directories, or in standard
    1030                 :            :    directories.  */
    1031                 :            : /* We pass any -flto flags on to the linker, which is expected
    1032                 :            :    to understand them.  In practice, this means it had better be collect2.  */
    1033                 :            : /* %{e*} includes -export-dynamic; see comment in common.opt.  */
    1034                 :            : #ifndef LINK_COMMAND_SPEC
    1035                 :            : #define LINK_COMMAND_SPEC "\
    1036                 :            : %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
    1037                 :            :     %(linker) " \
    1038                 :            :     LINK_PLUGIN_SPEC \
    1039                 :            :    "%{flto|flto=*:%<fcompare-debug*} \
    1040                 :            :     %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
    1041                 :            :    "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
    1042                 :            :    "%X %{o*} %{e*} %{N} %{n} %{r}\
    1043                 :            :     %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
    1044                 :            :     %{static|no-pie|static-pie:} %@{L*} %(mfwrap) %(link_libgcc) " \
    1045                 :            :     VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
    1046                 :            :     %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
    1047                 :            :         %:include(libgomp.spec)%(link_gomp)}\
    1048                 :            :     %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
    1049                 :            :     %(mflib) " STACK_SPLIT_SPEC "\
    1050                 :            :     %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
    1051                 :            :     %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
    1052                 :            :     %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*}  \n%(post_link) }}}}}}"
    1053                 :            : #endif
    1054                 :            : 
    1055                 :            : #ifndef LINK_LIBGCC_SPEC
    1056                 :            : /* Generate -L options for startfile prefix list.  */
    1057                 :            : # define LINK_LIBGCC_SPEC "%D"
    1058                 :            : #endif
    1059                 :            : 
    1060                 :            : #ifndef STARTFILE_PREFIX_SPEC
    1061                 :            : # define STARTFILE_PREFIX_SPEC ""
    1062                 :            : #endif
    1063                 :            : 
    1064                 :            : #ifndef SYSROOT_SPEC
    1065                 :            : # define SYSROOT_SPEC "--sysroot=%R"
    1066                 :            : #endif
    1067                 :            : 
    1068                 :            : #ifndef SYSROOT_SUFFIX_SPEC
    1069                 :            : # define SYSROOT_SUFFIX_SPEC ""
    1070                 :            : #endif
    1071                 :            : 
    1072                 :            : #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
    1073                 :            : # define SYSROOT_HEADERS_SUFFIX_SPEC ""
    1074                 :            : #endif
    1075                 :            : 
    1076                 :            : static const char *asm_debug = ASM_DEBUG_SPEC;
    1077                 :            : static const char *cpp_spec = CPP_SPEC;
    1078                 :            : static const char *cc1_spec = CC1_SPEC;
    1079                 :            : static const char *cc1plus_spec = CC1PLUS_SPEC;
    1080                 :            : static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
    1081                 :            : static const char *link_ssp_spec = LINK_SSP_SPEC;
    1082                 :            : static const char *asm_spec = ASM_SPEC;
    1083                 :            : static const char *asm_final_spec = ASM_FINAL_SPEC;
    1084                 :            : static const char *link_spec = LINK_SPEC;
    1085                 :            : static const char *lib_spec = LIB_SPEC;
    1086                 :            : static const char *link_gomp_spec = "";
    1087                 :            : static const char *libgcc_spec = LIBGCC_SPEC;
    1088                 :            : static const char *endfile_spec = ENDFILE_SPEC;
    1089                 :            : static const char *startfile_spec = STARTFILE_SPEC;
    1090                 :            : static const char *linker_name_spec = LINKER_NAME;
    1091                 :            : static const char *linker_plugin_file_spec = "";
    1092                 :            : static const char *lto_wrapper_spec = "";
    1093                 :            : static const char *lto_gcc_spec = "";
    1094                 :            : static const char *post_link_spec = POST_LINK_SPEC;
    1095                 :            : static const char *link_command_spec = LINK_COMMAND_SPEC;
    1096                 :            : static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
    1097                 :            : static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
    1098                 :            : static const char *sysroot_spec = SYSROOT_SPEC;
    1099                 :            : static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
    1100                 :            : static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
    1101                 :            : static const char *self_spec = "";
    1102                 :            : 
    1103                 :            : /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
    1104                 :            :    There should be no need to override these in target dependent files,
    1105                 :            :    but we need to copy them to the specs file so that newer versions
    1106                 :            :    of the GCC driver can correctly drive older tool chains with the
    1107                 :            :    appropriate -B options.  */
    1108                 :            : 
    1109                 :            : /* When cpplib handles traditional preprocessing, get rid of this, and
    1110                 :            :    call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
    1111                 :            :    that we default the front end language better.  */
    1112                 :            : static const char *trad_capable_cpp =
    1113                 :            : "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
    1114                 :            : 
    1115                 :            : /* We don't wrap .d files in %W{} since a missing .d file, and
    1116                 :            :    therefore no dependency entry, confuses make into thinking a .o
    1117                 :            :    file that happens to exist is up-to-date.  */
    1118                 :            : static const char *cpp_unique_options =
    1119                 :            : "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
    1120                 :            :  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
    1121                 :            :  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
    1122                 :            :  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
    1123                 :            :  %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
    1124                 :            :  %{remap} %{g3|ggdb3|gstabs3|gxcoff3|gvms3:-dD}\
    1125                 :            :  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
    1126                 :            :  %{H} %C %{D*&U*&A*} %{i*} %Z %i\
    1127                 :            :  %{E|M|MM:%W{o*}}";
    1128                 :            : 
    1129                 :            : /* This contains cpp options which are common with cc1_options and are passed
    1130                 :            :    only when preprocessing only to avoid duplication.  We pass the cc1 spec
    1131                 :            :    options to the preprocessor so that it the cc1 spec may manipulate
    1132                 :            :    options used to set target flags.  Those special target flags settings may
    1133                 :            :    in turn cause preprocessor symbols to be defined specially.  */
    1134                 :            : static const char *cpp_options =
    1135                 :            : "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
    1136                 :            :  %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
    1137                 :            :  %{!fno-working-directory:-fworking-directory}}} %{O*}\
    1138                 :            :  %{undef} %{save-temps*:-fpch-preprocess}";
    1139                 :            : 
    1140                 :            : /* This contains cpp options which are not passed when the preprocessor
    1141                 :            :    output will be used by another program.  */
    1142                 :            : static const char *cpp_debug_options = "%{d*}";
    1143                 :            : 
    1144                 :            : /* NB: This is shared amongst all front-ends, except for Ada.  */
    1145                 :            : static const char *cc1_options =
    1146                 :            : "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
    1147                 :            :  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
    1148                 :            :  %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
    1149                 :            :  %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
    1150                 :            :  %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
    1151                 :            :  %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
    1152                 :            :  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
    1153                 :            :  %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
    1154                 :            :  %{-target-help:--target-help}\
    1155                 :            :  %{-version:--version}\
    1156                 :            :  %{-help=*:--help=%*}\
    1157                 :            :  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
    1158                 :            :  %{fsyntax-only:-o %j} %{-param*}\
    1159                 :            :  %{coverage:-fprofile-arcs -ftest-coverage}\
    1160                 :            :  %{fprofile-arcs|fprofile-generate*|coverage:\
    1161                 :            :    %{!fprofile-update=single:\
    1162                 :            :      %{pthread:-fprofile-update=prefer-atomic}}}";
    1163                 :            : 
    1164                 :            : static const char *asm_options =
    1165                 :            : "%{-target-help:%:print-asm-header()} "
    1166                 :            : #if HAVE_GNU_AS
    1167                 :            : /* If GNU AS is used, then convert -w (no warnings), -I, and -v
    1168                 :            :    to the assembler equivalents.  */
    1169                 :            : "%{v} %{w:-W} %{I*} "
    1170                 :            : #endif
    1171                 :            : ASM_COMPRESS_DEBUG_SPEC
    1172                 :            : "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
    1173                 :            : 
    1174                 :            : static const char *invoke_as =
    1175                 :            : #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
    1176                 :            : "%{!fwpa*:\
    1177                 :            :    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
    1178                 :            :    %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
    1179                 :            :   }";
    1180                 :            : #else
    1181                 :            : "%{!fwpa*:\
    1182                 :            :    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
    1183                 :            :    %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
    1184                 :            :   }";
    1185                 :            : #endif
    1186                 :            : 
    1187                 :            : /* Some compilers have limits on line lengths, and the multilib_select
    1188                 :            :    and/or multilib_matches strings can be very long, so we build them at
    1189                 :            :    run time.  */
    1190                 :            : static struct obstack multilib_obstack;
    1191                 :            : static const char *multilib_select;
    1192                 :            : static const char *multilib_matches;
    1193                 :            : static const char *multilib_defaults;
    1194                 :            : static const char *multilib_exclusions;
    1195                 :            : static const char *multilib_reuse;
    1196                 :            : 
    1197                 :            : /* Check whether a particular argument is a default argument.  */
    1198                 :            : 
    1199                 :            : #ifndef MULTILIB_DEFAULTS
    1200                 :            : #define MULTILIB_DEFAULTS { "" }
    1201                 :            : #endif
    1202                 :            : 
    1203                 :            : static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
    1204                 :            : 
    1205                 :            : #ifndef DRIVER_SELF_SPECS
    1206                 :            : #define DRIVER_SELF_SPECS ""
    1207                 :            : #endif
    1208                 :            : 
    1209                 :            : /* Linking to libgomp implies pthreads.  This is particularly important
    1210                 :            :    for targets that use different start files and suchlike.  */
    1211                 :            : #ifndef GOMP_SELF_SPECS
    1212                 :            : #define GOMP_SELF_SPECS \
    1213                 :            :   "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
    1214                 :            :   "-pthread}"
    1215                 :            : #endif
    1216                 :            : 
    1217                 :            : /* Likewise for -fgnu-tm.  */
    1218                 :            : #ifndef GTM_SELF_SPECS
    1219                 :            : #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
    1220                 :            : #endif
    1221                 :            : 
    1222                 :            : static const char *const driver_self_specs[] = {
    1223                 :            :   "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
    1224                 :            :   DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS
    1225                 :            : };
    1226                 :            : 
    1227                 :            : #ifndef OPTION_DEFAULT_SPECS
    1228                 :            : #define OPTION_DEFAULT_SPECS { "", "" }
    1229                 :            : #endif
    1230                 :            : 
    1231                 :            : struct default_spec
    1232                 :            : {
    1233                 :            :   const char *name;
    1234                 :            :   const char *spec;
    1235                 :            : };
    1236                 :            : 
    1237                 :            : static const struct default_spec
    1238                 :            :   option_default_specs[] = { OPTION_DEFAULT_SPECS };
    1239                 :            : 
    1240                 :            : struct user_specs
    1241                 :            : {
    1242                 :            :   struct user_specs *next;
    1243                 :            :   const char *filename;
    1244                 :            : };
    1245                 :            : 
    1246                 :            : static struct user_specs *user_specs_head, *user_specs_tail;
    1247                 :            : 
    1248                 :            : 
    1249                 :            : /* Record the mapping from file suffixes for compilation specs.  */
    1250                 :            : 
    1251                 :            : struct compiler
    1252                 :            : {
    1253                 :            :   const char *suffix;           /* Use this compiler for input files
    1254                 :            :                                    whose names end in this suffix.  */
    1255                 :            : 
    1256                 :            :   const char *spec;             /* To use this compiler, run this spec.  */
    1257                 :            : 
    1258                 :            :   const char *cpp_spec;         /* If non-NULL, substitute this spec
    1259                 :            :                                    for `%C', rather than the usual
    1260                 :            :                                    cpp_spec.  */
    1261                 :            :   int combinable;               /* If nonzero, compiler can deal with
    1262                 :            :                                     multiple source files at once (IMA).  */
    1263                 :            :   int needs_preprocessing;       /* If nonzero, source files need to
    1264                 :            :                                     be run through a preprocessor.  */
    1265                 :            : };
    1266                 :            : 
    1267                 :            : /* Pointer to a vector of `struct compiler' that gives the spec for
    1268                 :            :    compiling a file, based on its suffix.
    1269                 :            :    A file that does not end in any of these suffixes will be passed
    1270                 :            :    unchanged to the loader and nothing else will be done to it.
    1271                 :            : 
    1272                 :            :    An entry containing two 0s is used to terminate the vector.
    1273                 :            : 
    1274                 :            :    If multiple entries match a file, the last matching one is used.  */
    1275                 :            : 
    1276                 :            : static struct compiler *compilers;
    1277                 :            : 
    1278                 :            : /* Number of entries in `compilers', not counting the null terminator.  */
    1279                 :            : 
    1280                 :            : static int n_compilers;
    1281                 :            : 
    1282                 :            : /* The default list of file name suffixes and their compilation specs.  */
    1283                 :            : 
    1284                 :            : static const struct compiler default_compilers[] =
    1285                 :            : {
    1286                 :            :   /* Add lists of suffixes of known languages here.  If those languages
    1287                 :            :      were not present when we built the driver, we will hit these copies
    1288                 :            :      and be given a more meaningful error than "file not used since
    1289                 :            :      linking is not done".  */
    1290                 :            :   {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
    1291                 :            :   {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
    1292                 :            :   {".mii", "#Objective-C++", 0, 0, 0},
    1293                 :            :   {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
    1294                 :            :   {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
    1295                 :            :   {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
    1296                 :            :   {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
    1297                 :            :   {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
    1298                 :            :   {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
    1299                 :            :   {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
    1300                 :            :   {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
    1301                 :            :   {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
    1302                 :            :   {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
    1303                 :            :   {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
    1304                 :            :   {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
    1305                 :            :   {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
    1306                 :            :   {".r", "#Ratfor", 0, 0, 0},
    1307                 :            :   {".go", "#Go", 0, 1, 0},
    1308                 :            :   {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
    1309                 :            :   /* Next come the entries for C.  */
    1310                 :            :   {".c", "@c", 0, 0, 1},
    1311                 :            :   {"@c",
    1312                 :            :    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
    1313                 :            :       external preprocessor if -save-temps is given.  */
    1314                 :            :      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
    1315                 :            :       %{!E:%{!M:%{!MM:\
    1316                 :            :           %{traditional:\
    1317                 :            : %eGNU C no longer supports -traditional without -E}\
    1318                 :            :       %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
    1319                 :            :           %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
    1320                 :            :             cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
    1321                 :            :           %(cc1_options)}\
    1322                 :            :       %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
    1323                 :            :           cc1 %(cpp_unique_options) %(cc1_options)}}}\
    1324                 :            :       %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
    1325                 :            :   {"-",
    1326                 :            :    "%{!E:%e-E or -x required when input is from standard input}\
    1327                 :            :     %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
    1328                 :            :   {".h", "@c-header", 0, 0, 0},
    1329                 :            :   {"@c-header",
    1330                 :            :    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
    1331                 :            :       external preprocessor if -save-temps is given.  */
    1332                 :            :      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
    1333                 :            :       %{!E:%{!M:%{!MM:\
    1334                 :            :           %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
    1335                 :            :                 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
    1336                 :            :                     cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
    1337                 :            :                         %(cc1_options)\
    1338                 :            :                         %{!fsyntax-only:%{!S:-o %g.s} \
    1339                 :            :                             %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
    1340                 :            :                                                %W{o*:--output-pch=%*}}%V}}\
    1341                 :            :           %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
    1342                 :            :                 cc1 %(cpp_unique_options) %(cc1_options)\
    1343                 :            :                     %{!fsyntax-only:%{!S:-o %g.s} \
    1344                 :            :                         %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
    1345                 :            :                                            %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0},
    1346                 :            :   {".i", "@cpp-output", 0, 0, 0},
    1347                 :            :   {"@cpp-output",
    1348                 :            :    "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
    1349                 :            :   {".s", "@assembler", 0, 0, 0},
    1350                 :            :   {"@assembler",
    1351                 :            :    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
    1352                 :            :   {".sx", "@assembler-with-cpp", 0, 0, 0},
    1353                 :            :   {".S", "@assembler-with-cpp", 0, 0, 0},
    1354                 :            :   {"@assembler-with-cpp",
    1355                 :            : #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
    1356                 :            :    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
    1357                 :            :       %{E|M|MM:%(cpp_debug_options)}\
    1358                 :            :       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
    1359                 :            :        as %(asm_debug) %(asm_options) %|.s %A }}}}"
    1360                 :            : #else
    1361                 :            :    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
    1362                 :            :       %{E|M|MM:%(cpp_debug_options)}\
    1363                 :            :       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
    1364                 :            :        as %(asm_debug) %(asm_options) %m.s %A }}}}"
    1365                 :            : #endif
    1366                 :            :    , 0, 0, 0},
    1367                 :            : 
    1368                 :            : #include "specs.h"
    1369                 :            :   /* Mark end of table.  */
    1370                 :            :   {0, 0, 0, 0, 0}
    1371                 :            : };
    1372                 :            : 
    1373                 :            : /* Number of elements in default_compilers, not counting the terminator.  */
    1374                 :            : 
    1375                 :            : static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
    1376                 :            : 
    1377                 :            : typedef char *char_p; /* For DEF_VEC_P.  */
    1378                 :            : 
    1379                 :            : /* A vector of options to give to the linker.
    1380                 :            :    These options are accumulated by %x,
    1381                 :            :    and substituted into the linker command with %X.  */
    1382                 :            : static vec<char_p> linker_options;
    1383                 :            : 
    1384                 :            : /* A vector of options to give to the assembler.
    1385                 :            :    These options are accumulated by -Wa,
    1386                 :            :    and substituted into the assembler command with %Y.  */
    1387                 :            : static vec<char_p> assembler_options;
    1388                 :            : 
    1389                 :            : /* A vector of options to give to the preprocessor.
    1390                 :            :    These options are accumulated by -Wp,
    1391                 :            :    and substituted into the preprocessor command with %Z.  */
    1392                 :            : static vec<char_p> preprocessor_options;
    1393                 :            : 
    1394                 :            : static char *
    1395                 :   18906700 : skip_whitespace (char *p)
    1396                 :            : {
    1397                 :   43757300 :   while (1)
    1398                 :            :     {
    1399                 :            :       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
    1400                 :            :          be considered whitespace.  */
    1401                 :   43757300 :       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
    1402                 :    3238770 :         return p + 1;
    1403                 :   40518500 :       else if (*p == '\n' || *p == ' ' || *p == '\t')
    1404                 :   24755800 :         p++;
    1405                 :   15762800 :       else if (*p == '#')
    1406                 :            :         {
    1407                 :    2867000 :           while (*p != '\n')
    1408                 :    2772180 :             p++;
    1409                 :      94813 :           p++;
    1410                 :            :         }
    1411                 :            :       else
    1412                 :            :         break;
    1413                 :            :     }
    1414                 :            : 
    1415                 :            :   return p;
    1416                 :            : }
    1417                 :            : /* Structures to keep track of prefixes to try when looking for files.  */
    1418                 :            : 
    1419                 :            : struct prefix_list
    1420                 :            : {
    1421                 :            :   const char *prefix;         /* String to prepend to the path.  */
    1422                 :            :   struct prefix_list *next;   /* Next in linked list.  */
    1423                 :            :   int require_machine_suffix; /* Don't use without machine_suffix.  */
    1424                 :            :   /* 2 means try both machine_suffix and just_machine_suffix.  */
    1425                 :            :   int priority;               /* Sort key - priority within list.  */
    1426                 :            :   int os_multilib;            /* 1 if OS multilib scheme should be used,
    1427                 :            :                                  0 for GCC multilib scheme.  */
    1428                 :            : };
    1429                 :            : 
    1430                 :            : struct path_prefix
    1431                 :            : {
    1432                 :            :   struct prefix_list *plist;  /* List of prefixes to try */
    1433                 :            :   int max_len;                /* Max length of a prefix in PLIST */
    1434                 :            :   const char *name;           /* Name of this list (used in config stuff) */
    1435                 :            : };
    1436                 :            : 
    1437                 :            : /* List of prefixes to try when looking for executables.  */
    1438                 :            : 
    1439                 :            : static struct path_prefix exec_prefixes = { 0, 0, "exec" };
    1440                 :            : 
    1441                 :            : /* List of prefixes to try when looking for startup (crt0) files.  */
    1442                 :            : 
    1443                 :            : static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
    1444                 :            : 
    1445                 :            : /* List of prefixes to try when looking for include files.  */
    1446                 :            : 
    1447                 :            : static struct path_prefix include_prefixes = { 0, 0, "include" };
    1448                 :            : 
    1449                 :            : /* Suffix to attach to directories searched for commands.
    1450                 :            :    This looks like `MACHINE/VERSION/'.  */
    1451                 :            : 
    1452                 :            : static const char *machine_suffix = 0;
    1453                 :            : 
    1454                 :            : /* Suffix to attach to directories searched for commands.
    1455                 :            :    This is just `MACHINE/'.  */
    1456                 :            : 
    1457                 :            : static const char *just_machine_suffix = 0;
    1458                 :            : 
    1459                 :            : /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
    1460                 :            : 
    1461                 :            : static const char *gcc_exec_prefix;
    1462                 :            : 
    1463                 :            : /* Adjusted value of standard_libexec_prefix.  */
    1464                 :            : 
    1465                 :            : static const char *gcc_libexec_prefix;
    1466                 :            : 
    1467                 :            : /* Default prefixes to attach to command names.  */
    1468                 :            : 
    1469                 :            : #ifndef STANDARD_STARTFILE_PREFIX_1
    1470                 :            : #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
    1471                 :            : #endif
    1472                 :            : #ifndef STANDARD_STARTFILE_PREFIX_2
    1473                 :            : #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
    1474                 :            : #endif
    1475                 :            : 
    1476                 :            : #ifdef CROSS_DIRECTORY_STRUCTURE  /* Don't use these prefixes for a cross compiler.  */
    1477                 :            : #undef MD_EXEC_PREFIX
    1478                 :            : #undef MD_STARTFILE_PREFIX
    1479                 :            : #undef MD_STARTFILE_PREFIX_1
    1480                 :            : #endif
    1481                 :            : 
    1482                 :            : /* If no prefixes defined, use the null string, which will disable them.  */
    1483                 :            : #ifndef MD_EXEC_PREFIX
    1484                 :            : #define MD_EXEC_PREFIX ""
    1485                 :            : #endif
    1486                 :            : #ifndef MD_STARTFILE_PREFIX
    1487                 :            : #define MD_STARTFILE_PREFIX ""
    1488                 :            : #endif
    1489                 :            : #ifndef MD_STARTFILE_PREFIX_1
    1490                 :            : #define MD_STARTFILE_PREFIX_1 ""
    1491                 :            : #endif
    1492                 :            : 
    1493                 :            : /* These directories are locations set at configure-time based on the
    1494                 :            :    --prefix option provided to configure.  Their initializers are
    1495                 :            :    defined in Makefile.in.  These paths are not *directly* used when
    1496                 :            :    gcc_exec_prefix is set because, in that case, we know where the
    1497                 :            :    compiler has been installed, and use paths relative to that
    1498                 :            :    location instead.  */
    1499                 :            : static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
    1500                 :            : static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
    1501                 :            : static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
    1502                 :            : static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
    1503                 :            : 
    1504                 :            : /* For native compilers, these are well-known paths containing
    1505                 :            :    components that may be provided by the system.  For cross
    1506                 :            :    compilers, these paths are not used.  */
    1507                 :            : static const char *md_exec_prefix = MD_EXEC_PREFIX;
    1508                 :            : static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
    1509                 :            : static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
    1510                 :            : static const char *const standard_startfile_prefix_1
    1511                 :            :   = STANDARD_STARTFILE_PREFIX_1;
    1512                 :            : static const char *const standard_startfile_prefix_2
    1513                 :            :   = STANDARD_STARTFILE_PREFIX_2;
    1514                 :            : 
    1515                 :            : /* A relative path to be used in finding the location of tools
    1516                 :            :    relative to the driver.  */
    1517                 :            : static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
    1518                 :            : 
    1519                 :            : /* A prefix to be used when this is an accelerator compiler.  */
    1520                 :            : static const char *const accel_dir_suffix = ACCEL_DIR_SUFFIX;
    1521                 :            : 
    1522                 :            : /* Subdirectory to use for locating libraries.  Set by
    1523                 :            :    set_multilib_dir based on the compilation options.  */
    1524                 :            : 
    1525                 :            : static const char *multilib_dir;
    1526                 :            : 
    1527                 :            : /* Subdirectory to use for locating libraries in OS conventions.  Set by
    1528                 :            :    set_multilib_dir based on the compilation options.  */
    1529                 :            : 
    1530                 :            : static const char *multilib_os_dir;
    1531                 :            : 
    1532                 :            : /* Subdirectory to use for locating libraries in multiarch conventions.  Set by
    1533                 :            :    set_multilib_dir based on the compilation options.  */
    1534                 :            : 
    1535                 :            : static const char *multiarch_dir;
    1536                 :            : 
    1537                 :            : /* Structure to keep track of the specs that have been defined so far.
    1538                 :            :    These are accessed using %(specname) in a compiler or link
    1539                 :            :    spec.  */
    1540                 :            : 
    1541                 :            : struct spec_list
    1542                 :            : {
    1543                 :            :                                 /* The following 2 fields must be first */
    1544                 :            :                                 /* to allow EXTRA_SPECS to be initialized */
    1545                 :            :   const char *name;             /* name of the spec.  */
    1546                 :            :   const char *ptr;              /* available ptr if no static pointer */
    1547                 :            : 
    1548                 :            :                                 /* The following fields are not initialized */
    1549                 :            :                                 /* by EXTRA_SPECS */
    1550                 :            :   const char **ptr_spec;        /* pointer to the spec itself.  */
    1551                 :            :   struct spec_list *next;       /* Next spec in linked list.  */
    1552                 :            :   int name_len;                 /* length of the name */
    1553                 :            :   bool user_p;                  /* whether string come from file spec.  */
    1554                 :            :   bool alloc_p;                 /* whether string was allocated */
    1555                 :            :   const char *default_ptr;      /* The default value of *ptr_spec.  */
    1556                 :            : };
    1557                 :            : 
    1558                 :            : #define INIT_STATIC_SPEC(NAME,PTR) \
    1559                 :            :   { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
    1560                 :            :     *PTR }
    1561                 :            : 
    1562                 :            : /* List of statically defined specs.  */
    1563                 :            : static struct spec_list static_specs[] =
    1564                 :            : {
    1565                 :            :   INIT_STATIC_SPEC ("asm",                    &asm_spec),
    1566                 :            :   INIT_STATIC_SPEC ("asm_debug",              &asm_debug),
    1567                 :            :   INIT_STATIC_SPEC ("asm_final",              &asm_final_spec),
    1568                 :            :   INIT_STATIC_SPEC ("asm_options",            &asm_options),
    1569                 :            :   INIT_STATIC_SPEC ("invoke_as",              &invoke_as),
    1570                 :            :   INIT_STATIC_SPEC ("cpp",                    &cpp_spec),
    1571                 :            :   INIT_STATIC_SPEC ("cpp_options",            &cpp_options),
    1572                 :            :   INIT_STATIC_SPEC ("cpp_debug_options",      &cpp_debug_options),
    1573                 :            :   INIT_STATIC_SPEC ("cpp_unique_options",     &cpp_unique_options),
    1574                 :            :   INIT_STATIC_SPEC ("trad_capable_cpp",               &trad_capable_cpp),
    1575                 :            :   INIT_STATIC_SPEC ("cc1",                    &cc1_spec),
    1576                 :            :   INIT_STATIC_SPEC ("cc1_options",            &cc1_options),
    1577                 :            :   INIT_STATIC_SPEC ("cc1plus",                        &cc1plus_spec),
    1578                 :            :   INIT_STATIC_SPEC ("link_gcc_c_sequence",    &link_gcc_c_sequence_spec),
    1579                 :            :   INIT_STATIC_SPEC ("link_ssp",                       &link_ssp_spec),
    1580                 :            :   INIT_STATIC_SPEC ("endfile",                        &endfile_spec),
    1581                 :            :   INIT_STATIC_SPEC ("link",                   &link_spec),
    1582                 :            :   INIT_STATIC_SPEC ("lib",                    &lib_spec),
    1583                 :            :   INIT_STATIC_SPEC ("link_gomp",              &link_gomp_spec),
    1584                 :            :   INIT_STATIC_SPEC ("libgcc",                 &libgcc_spec),
    1585                 :            :   INIT_STATIC_SPEC ("startfile",              &startfile_spec),
    1586                 :            :   INIT_STATIC_SPEC ("cross_compile",          &cross_compile),
    1587                 :            :   INIT_STATIC_SPEC ("version",                        &compiler_version),
    1588                 :            :   INIT_STATIC_SPEC ("multilib",                       &multilib_select),
    1589                 :            :   INIT_STATIC_SPEC ("multilib_defaults",      &multilib_defaults),
    1590                 :            :   INIT_STATIC_SPEC ("multilib_extra",         &multilib_extra),
    1591                 :            :   INIT_STATIC_SPEC ("multilib_matches",               &multilib_matches),
    1592                 :            :   INIT_STATIC_SPEC ("multilib_exclusions",    &multilib_exclusions),
    1593                 :            :   INIT_STATIC_SPEC ("multilib_options",               &multilib_options),
    1594                 :            :   INIT_STATIC_SPEC ("multilib_reuse",         &multilib_reuse),
    1595                 :            :   INIT_STATIC_SPEC ("linker",                 &linker_name_spec),
    1596                 :            :   INIT_STATIC_SPEC ("linker_plugin_file",     &linker_plugin_file_spec),
    1597                 :            :   INIT_STATIC_SPEC ("lto_wrapper",            &lto_wrapper_spec),
    1598                 :            :   INIT_STATIC_SPEC ("lto_gcc",                        &lto_gcc_spec),
    1599                 :            :   INIT_STATIC_SPEC ("post_link",              &post_link_spec),
    1600                 :            :   INIT_STATIC_SPEC ("link_libgcc",            &link_libgcc_spec),
    1601                 :            :   INIT_STATIC_SPEC ("md_exec_prefix",         &md_exec_prefix),
    1602                 :            :   INIT_STATIC_SPEC ("md_startfile_prefix",    &md_startfile_prefix),
    1603                 :            :   INIT_STATIC_SPEC ("md_startfile_prefix_1",  &md_startfile_prefix_1),
    1604                 :            :   INIT_STATIC_SPEC ("startfile_prefix_spec",  &startfile_prefix_spec),
    1605                 :            :   INIT_STATIC_SPEC ("sysroot_spec",             &sysroot_spec),
    1606                 :            :   INIT_STATIC_SPEC ("sysroot_suffix_spec",    &sysroot_suffix_spec),
    1607                 :            :   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec",       &sysroot_hdrs_suffix_spec),
    1608                 :            :   INIT_STATIC_SPEC ("self_spec",              &self_spec),
    1609                 :            : };
    1610                 :            : 
    1611                 :            : #ifdef EXTRA_SPECS              /* additional specs needed */
    1612                 :            : /* Structure to keep track of just the first two args of a spec_list.
    1613                 :            :    That is all that the EXTRA_SPECS macro gives us.  */
    1614                 :            : struct spec_list_1
    1615                 :            : {
    1616                 :            :   const char *const name;
    1617                 :            :   const char *const ptr;
    1618                 :            : };
    1619                 :            : 
    1620                 :            : static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
    1621                 :            : static struct spec_list *extra_specs = (struct spec_list *) 0;
    1622                 :            : #endif
    1623                 :            : 
    1624                 :            : /* List of dynamically allocates specs that have been defined so far.  */
    1625                 :            : 
    1626                 :            : static struct spec_list *specs = (struct spec_list *) 0;
    1627                 :            : 
    1628                 :            : /* List of static spec functions.  */
    1629                 :            : 
    1630                 :            : static const struct spec_function static_spec_functions[] =
    1631                 :            : {
    1632                 :            :   { "getenv",                   getenv_spec_function },
    1633                 :            :   { "if-exists",              if_exists_spec_function },
    1634                 :            :   { "if-exists-else",         if_exists_else_spec_function },
    1635                 :            :   { "sanitize",                       sanitize_spec_function },
    1636                 :            :   { "replace-outfile",                replace_outfile_spec_function },
    1637                 :            :   { "remove-outfile",         remove_outfile_spec_function },
    1638                 :            :   { "version-compare",                version_compare_spec_function },
    1639                 :            :   { "include",                        include_spec_function },
    1640                 :            :   { "find-file",              find_file_spec_function },
    1641                 :            :   { "find-plugindir",         find_plugindir_spec_function },
    1642                 :            :   { "print-asm-header",               print_asm_header_spec_function },
    1643                 :            :   { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
    1644                 :            :   { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
    1645                 :            :   { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
    1646                 :            :   { "pass-through-libs",      pass_through_libs_spec_func },
    1647                 :            :   { "replace-extension",      replace_extension_spec_func },
    1648                 :            :   { "gt",                     greater_than_spec_func },
    1649                 :            :   { "debug-level-gt",         debug_level_greater_than_spec_func },
    1650                 :            :   { "fortran-preinclude-file",        find_fortran_preinclude_file},
    1651                 :            : #ifdef EXTRA_SPEC_FUNCTIONS
    1652                 :            :   EXTRA_SPEC_FUNCTIONS
    1653                 :            : #endif
    1654                 :            :   { 0, 0 }
    1655                 :            : };
    1656                 :            : 
    1657                 :            : static int processing_spec_function;
    1658                 :            : 
    1659                 :            : /* Add appropriate libgcc specs to OBSTACK, taking into account
    1660                 :            :    various permutations of -shared-libgcc, -shared, and such.  */
    1661                 :            : 
    1662                 :            : #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
    1663                 :            : 
    1664                 :            : #ifndef USE_LD_AS_NEEDED
    1665                 :            : #define USE_LD_AS_NEEDED 0
    1666                 :            : #endif
    1667                 :            : 
    1668                 :            : static void
    1669                 :        314 : init_gcc_specs (struct obstack *obstack, const char *shared_name,
    1670                 :            :                 const char *static_name, const char *eh_name)
    1671                 :            : {
    1672                 :        314 :   char *buf;
    1673                 :            : 
    1674                 :            : #if USE_LD_AS_NEEDED
    1675                 :        314 :   buf = concat ("%{static|static-libgcc|static-pie:", static_name, " ", eh_name, "}"
    1676                 :            :                 "%{!static:%{!static-libgcc:%{!static-pie:"
    1677                 :            :                 "%{!shared-libgcc:",
    1678                 :            :                 static_name, " " LD_AS_NEEDED_OPTION " ",
    1679                 :            :                 shared_name, " " LD_NO_AS_NEEDED_OPTION
    1680                 :            :                 "}"
    1681                 :            :                 "%{shared-libgcc:",
    1682                 :            :                 shared_name, "%{!shared: ", static_name, "}"
    1683                 :            :                 "}}"
    1684                 :            : #else
    1685                 :            :   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
    1686                 :            :                 "%{!static:%{!static-libgcc:"
    1687                 :            :                 "%{!shared:"
    1688                 :            :                 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
    1689                 :            :                 "%{shared-libgcc:", shared_name, " ", static_name, "}"
    1690                 :            :                 "}"
    1691                 :            : #ifdef LINK_EH_SPEC
    1692                 :            :                 "%{shared:"
    1693                 :            :                 "%{shared-libgcc:", shared_name, "}"
    1694                 :            :                 "%{!shared-libgcc:", static_name, "}"
    1695                 :            :                 "}"
    1696                 :            : #else
    1697                 :            :                 "%{shared:", shared_name, "}"
    1698                 :            : #endif
    1699                 :            : #endif
    1700                 :            :                 "}}", NULL);
    1701                 :            : 
    1702                 :        314 :   obstack_grow (obstack, buf, strlen (buf));
    1703                 :        314 :   free (buf);
    1704                 :        314 : }
    1705                 :            : #endif /* ENABLE_SHARED_LIBGCC */
    1706                 :            : 
    1707                 :            : /* Initialize the specs lookup routines.  */
    1708                 :            : 
    1709                 :            : static void
    1710                 :        314 : init_spec (void)
    1711                 :            : {
    1712                 :        314 :   struct spec_list *next = (struct spec_list *) 0;
    1713                 :        314 :   struct spec_list *sl   = (struct spec_list *) 0;
    1714                 :        314 :   int i;
    1715                 :            : 
    1716                 :        314 :   if (specs)
    1717                 :            :     return;                     /* Already initialized.  */
    1718                 :            : 
    1719                 :        314 :   if (verbose_flag)
    1720                 :         35 :     fnotice (stderr, "Using built-in specs.\n");
    1721                 :            : 
    1722                 :            : #ifdef EXTRA_SPECS
    1723                 :        314 :   extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
    1724                 :            : 
    1725                 :        628 :   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
    1726                 :            :     {
    1727                 :        314 :       sl = &extra_specs[i];
    1728                 :        314 :       sl->name = extra_specs_1[i].name;
    1729                 :        314 :       sl->ptr = extra_specs_1[i].ptr;
    1730                 :        314 :       sl->next = next;
    1731                 :        314 :       sl->name_len = strlen (sl->name);
    1732                 :        314 :       sl->ptr_spec = &sl->ptr;
    1733                 :        314 :       gcc_assert (sl->ptr_spec != NULL);
    1734                 :        314 :       sl->default_ptr = sl->ptr;
    1735                 :        314 :       next = sl;
    1736                 :            :     }
    1737                 :            : #endif
    1738                 :            : 
    1739                 :      14130 :   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
    1740                 :            :     {
    1741                 :      13816 :       sl = &static_specs[i];
    1742                 :      13816 :       sl->next = next;
    1743                 :      13816 :       next = sl;
    1744                 :            :     }
    1745                 :            : 
    1746                 :            : #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
    1747                 :            :   /* ??? If neither -shared-libgcc nor --static-libgcc was
    1748                 :            :      seen, then we should be making an educated guess.  Some proposed
    1749                 :            :      heuristics for ELF include:
    1750                 :            : 
    1751                 :            :         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
    1752                 :            :             program will be doing dynamic loading, which will likely
    1753                 :            :             need the shared libgcc.
    1754                 :            : 
    1755                 :            :         (2) If "-ldl", then it's also a fair bet that we're doing
    1756                 :            :             dynamic loading.
    1757                 :            : 
    1758                 :            :         (3) For each ET_DYN we're linking against (either through -lfoo
    1759                 :            :             or /some/path/foo.so), check to see whether it or one of
    1760                 :            :             its dependencies depends on a shared libgcc.
    1761                 :            : 
    1762                 :            :         (4) If "-shared"
    1763                 :            : 
    1764                 :            :             If the runtime is fixed to look for program headers instead
    1765                 :            :             of calling __register_frame_info at all, for each object,
    1766                 :            :             use the shared libgcc if any EH symbol referenced.
    1767                 :            : 
    1768                 :            :             If crtstuff is fixed to not invoke __register_frame_info
    1769                 :            :             automatically, for each object, use the shared libgcc if
    1770                 :            :             any non-empty unwind section found.
    1771                 :            : 
    1772                 :            :      Doing any of this probably requires invoking an external program to
    1773                 :            :      do the actual object file scanning.  */
    1774                 :        314 :   {
    1775                 :        314 :     const char *p = libgcc_spec;
    1776                 :        314 :     int in_sep = 1;
    1777                 :            : 
    1778                 :            :     /* Transform the extant libgcc_spec into one that uses the shared libgcc
    1779                 :            :        when given the proper command line arguments.  */
    1780                 :        628 :     while (*p)
    1781                 :            :       {
    1782                 :        314 :         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
    1783                 :            :           {
    1784                 :        314 :             init_gcc_specs (&obstack,
    1785                 :            :                             "-lgcc_s"
    1786                 :            : #ifdef USE_LIBUNWIND_EXCEPTIONS
    1787                 :            :                             " -lunwind"
    1788                 :            : #endif
    1789                 :            :                             ,
    1790                 :            :                             "-lgcc",
    1791                 :            :                             "-lgcc_eh"
    1792                 :            : #ifdef USE_LIBUNWIND_EXCEPTIONS
    1793                 :            : # ifdef HAVE_LD_STATIC_DYNAMIC
    1794                 :            :                             " %{!static:%{!static-pie:" LD_STATIC_OPTION "}} -lunwind"
    1795                 :            :                             " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION "}}"
    1796                 :            : # else
    1797                 :            :                             " -lunwind"
    1798                 :            : # endif
    1799                 :            : #endif
    1800                 :            :                             );
    1801                 :            : 
    1802                 :        314 :             p += 5;
    1803                 :        314 :             in_sep = 0;
    1804                 :            :           }
    1805                 :          0 :         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
    1806                 :            :           {
    1807                 :            :             /* Ug.  We don't know shared library extensions.  Hope that
    1808                 :            :                systems that use this form don't do shared libraries.  */
    1809                 :          0 :             init_gcc_specs (&obstack,
    1810                 :            :                             "-lgcc_s",
    1811                 :            :                             "libgcc.a%s",
    1812                 :            :                             "libgcc_eh.a%s"
    1813                 :            : #ifdef USE_LIBUNWIND_EXCEPTIONS
    1814                 :            :                             " -lunwind"
    1815                 :            : #endif
    1816                 :            :                             );
    1817                 :          0 :             p += 10;
    1818                 :          0 :             in_sep = 0;
    1819                 :            :           }
    1820                 :            :         else
    1821                 :            :           {
    1822                 :          0 :             obstack_1grow (&obstack, *p);
    1823                 :          0 :             in_sep = (*p == ' ');
    1824                 :          0 :             p += 1;
    1825                 :            :           }
    1826                 :            :       }
    1827                 :            : 
    1828                 :        314 :     obstack_1grow (&obstack, '\0');
    1829                 :        314 :     libgcc_spec = XOBFINISH (&obstack, const char *);
    1830                 :            :   }
    1831                 :            : #endif
    1832                 :            : #ifdef USE_AS_TRADITIONAL_FORMAT
    1833                 :            :   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
    1834                 :            :   {
    1835                 :            :     static const char tf[] = "--traditional-format ";
    1836                 :            :     obstack_grow (&obstack, tf, sizeof (tf) - 1);
    1837                 :            :     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
    1838                 :            :     asm_spec = XOBFINISH (&obstack, const char *);
    1839                 :            :   }
    1840                 :            : #endif
    1841                 :            : 
    1842                 :            : #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
    1843                 :            :     defined LINKER_HASH_STYLE
    1844                 :            : # ifdef LINK_BUILDID_SPEC
    1845                 :            :   /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before.  */
    1846                 :            :   obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1);
    1847                 :            : # endif
    1848                 :            : # ifdef LINK_EH_SPEC
    1849                 :            :   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
    1850                 :        314 :   obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1);
    1851                 :            : # endif
    1852                 :            : # ifdef LINKER_HASH_STYLE
    1853                 :            :   /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
    1854                 :            :      before.  */
    1855                 :            :   {
    1856                 :            :     static const char hash_style[] = "--hash-style=";
    1857                 :            :     obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
    1858                 :            :     obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
    1859                 :            :     obstack_1grow (&obstack, ' ');
    1860                 :            :   }
    1861                 :            : # endif
    1862                 :        314 :   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
    1863                 :        314 :   link_spec = XOBFINISH (&obstack, const char *);
    1864                 :            : #endif
    1865                 :            : 
    1866                 :        314 :   specs = sl;
    1867                 :            : }
    1868                 :            : 
    1869                 :            : /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
    1870                 :            :    removed; If the spec starts with a + then SPEC is added to the end of the
    1871                 :            :    current spec.  */
    1872                 :            : 
    1873                 :            : static void
    1874                 :    9147780 : set_spec (const char *name, const char *spec, bool user_p)
    1875                 :            : {
    1876                 :    9147780 :   struct spec_list *sl;
    1877                 :    9147780 :   const char *old_spec;
    1878                 :    9147780 :   int name_len = strlen (name);
    1879                 :    9147780 :   int i;
    1880                 :            : 
    1881                 :            :   /* If this is the first call, initialize the statically allocated specs.  */
    1882                 :    9147780 :   if (!specs)
    1883                 :            :     {
    1884                 :            :       struct spec_list *next = (struct spec_list *) 0;
    1885                 :    9109040 :       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
    1886                 :            :         {
    1887                 :    8906610 :           sl = &static_specs[i];
    1888                 :    8906610 :           sl->next = next;
    1889                 :    8906610 :           next = sl;
    1890                 :            :         }
    1891                 :     202423 :       specs = sl;
    1892                 :            :     }
    1893                 :            : 
    1894                 :            :   /* See if the spec already exists.  */
    1895                 :  210738000 :   for (sl = specs; sl; sl = sl->next)
    1896                 :  210518000 :     if (name_len == sl->name_len && !strcmp (sl->name, name))
    1897                 :            :       break;
    1898                 :            : 
    1899                 :    9147780 :   if (!sl)
    1900                 :            :     {
    1901                 :            :       /* Not found - make it.  */
    1902                 :     219912 :       sl = XNEW (struct spec_list);
    1903                 :     219912 :       sl->name = xstrdup (name);
    1904                 :     219912 :       sl->name_len = name_len;
    1905                 :     219912 :       sl->ptr_spec = &sl->ptr;
    1906                 :     219912 :       sl->alloc_p = 0;
    1907                 :     219912 :       *(sl->ptr_spec) = "";
    1908                 :     219912 :       sl->next = specs;
    1909                 :     219912 :       sl->default_ptr = NULL;
    1910                 :     219912 :       specs = sl;
    1911                 :            :     }
    1912                 :            : 
    1913                 :    9147780 :   old_spec = *(sl->ptr_spec);
    1914                 :    9147780 :   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
    1915                 :          1 :                      ? concat (old_spec, spec + 1, NULL)
    1916                 :    9147780 :                      : xstrdup (spec));
    1917                 :            : 
    1918                 :            : #ifdef DEBUG_SPECS
    1919                 :            :   if (verbose_flag)
    1920                 :            :     fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
    1921                 :            : #endif
    1922                 :            : 
    1923                 :            :   /* Free the old spec.  */
    1924                 :    9147780 :   if (old_spec && sl->alloc_p)
    1925                 :       3848 :     free (CONST_CAST (char *, old_spec));
    1926                 :            : 
    1927                 :    9147780 :   sl->user_p = user_p;
    1928                 :    9147780 :   sl->alloc_p = true;
    1929                 :    9147780 : }
    1930                 :            : 
    1931                 :            : /* Accumulate a command (program name and args), and run it.  */
    1932                 :            : 
    1933                 :            : typedef const char *const_char_p; /* For DEF_VEC_P.  */
    1934                 :            : 
    1935                 :            : /* Vector of pointers to arguments in the current line of specifications.  */
    1936                 :            : static vec<const_char_p> argbuf;
    1937                 :            : 
    1938                 :            : /* Likewise, but for the current @file.  */
    1939                 :            : static vec<const_char_p> at_file_argbuf;
    1940                 :            : 
    1941                 :            : /* Whether an @file is currently open.  */
    1942                 :            : static bool in_at_file = false;
    1943                 :            : 
    1944                 :            : /* Were the options -c, -S or -E passed.  */
    1945                 :            : static int have_c = 0;
    1946                 :            : 
    1947                 :            : /* Was the option -o passed.  */
    1948                 :            : static int have_o = 0;
    1949                 :            : 
    1950                 :            : /* Was the option -E passed.  */
    1951                 :            : static int have_E = 0;
    1952                 :            : 
    1953                 :            : /* Pointer to output file name passed in with -o. */
    1954                 :            : static const char *output_file = 0;
    1955                 :            : 
    1956                 :            : /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
    1957                 :            :    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
    1958                 :            :    it here.  */
    1959                 :            : 
    1960                 :            : static struct temp_name {
    1961                 :            :   const char *suffix;   /* suffix associated with the code.  */
    1962                 :            :   int length;           /* strlen (suffix).  */
    1963                 :            :   int unique;           /* Indicates whether %g or %u/%U was used.  */
    1964                 :            :   const char *filename; /* associated filename.  */
    1965                 :            :   int filename_length;  /* strlen (filename).  */
    1966                 :            :   struct temp_name *next;
    1967                 :            : } *temp_names;
    1968                 :            : 
    1969                 :            : /* Number of commands executed so far.  */
    1970                 :            : 
    1971                 :            : static int execution_count;
    1972                 :            : 
    1973                 :            : /* Number of commands that exited with a signal.  */
    1974                 :            : 
    1975                 :            : static int signal_count;
    1976                 :            : 
    1977                 :            : /* Allocate the argument vector.  */
    1978                 :            : 
    1979                 :            : static void
    1980                 :    1107000 : alloc_args (void)
    1981                 :            : {
    1982                 :    1107000 :   argbuf.create (10);
    1983                 :    1107000 :   at_file_argbuf.create (10);
    1984                 :    1107000 : }
    1985                 :            : 
    1986                 :            : /* Clear out the vector of arguments (after a command is executed).  */
    1987                 :            : 
    1988                 :            : static void
    1989                 :    3117260 : clear_args (void)
    1990                 :            : {
    1991                 :    3117260 :   argbuf.truncate (0);
    1992                 :    3117260 :   at_file_argbuf.truncate (0);
    1993                 :    3117260 : }
    1994                 :            : 
    1995                 :            : /* Add one argument to the vector at the end.
    1996                 :            :    This is done when a space is seen or at the end of the line.
    1997                 :            :    If DELETE_ALWAYS is nonzero, the arg is a filename
    1998                 :            :     and the file should be deleted eventually.
    1999                 :            :    If DELETE_FAILURE is nonzero, the arg is a filename
    2000                 :            :     and the file should be deleted if this compilation fails.  */
    2001                 :            : 
    2002                 :            : static void
    2003                 :   12582500 : store_arg (const char *arg, int delete_always, int delete_failure)
    2004                 :            : {
    2005                 :   12582500 :   if (in_at_file)
    2006                 :      14928 :     at_file_argbuf.safe_push (arg);
    2007                 :            :   else
    2008                 :   12567600 :     argbuf.safe_push (arg);
    2009                 :            : 
    2010                 :   12582500 :   if (delete_always || delete_failure)
    2011                 :            :     {
    2012                 :     381672 :       const char *p;
    2013                 :            :       /* If the temporary file we should delete is specified as
    2014                 :            :          part of a joined argument extract the filename.  */
    2015                 :     381672 :       if (arg[0] == '-'
    2016                 :     381672 :           && (p = strrchr (arg, '=')))
    2017                 :      69154 :         arg = p + 1;
    2018                 :     381672 :       record_temp_file (arg, delete_always, delete_failure);
    2019                 :            :     }
    2020                 :   12582500 : }
    2021                 :            : 
    2022                 :            : /* Open a temporary @file into which subsequent arguments will be stored.  */
    2023                 :            : 
    2024                 :            : static void
    2025                 :      13991 : open_at_file (void)
    2026                 :            : {
    2027                 :          0 :    if (in_at_file)
    2028                 :          0 :      fatal_error (input_location, "cannot open nested response file");
    2029                 :            :    else
    2030                 :      13991 :      in_at_file = true;
    2031                 :      13991 : }
    2032                 :            : 
    2033                 :            : /* Close the temporary @file and add @file to the argument list.  */
    2034                 :            : 
    2035                 :            : static void
    2036                 :      13991 : close_at_file (void)
    2037                 :            : {
    2038                 :      13991 :   if (!in_at_file)
    2039                 :          0 :     fatal_error (input_location, "cannot close nonexistent response file");
    2040                 :            : 
    2041                 :      13991 :   in_at_file = false;
    2042                 :            : 
    2043                 :      13991 :   const unsigned int n_args = at_file_argbuf.length ();
    2044                 :      13991 :   if (n_args == 0)
    2045                 :            :     return;
    2046                 :            : 
    2047                 :      13991 :   char **argv = (char **) alloca (sizeof (char *) * (n_args + 1));
    2048                 :      13991 :   char *temp_file = make_temp_file ("");
    2049                 :      13991 :   char *at_argument = concat ("@", temp_file, NULL);
    2050                 :      13991 :   FILE *f = fopen (temp_file, "w");
    2051                 :      13991 :   int status;
    2052                 :      13991 :   unsigned int i;
    2053                 :            : 
    2054                 :            :   /* Copy the strings over.  */
    2055                 :      28919 :   for (i = 0; i < n_args; i++)
    2056                 :      14928 :     argv[i] = CONST_CAST (char *, at_file_argbuf[i]);
    2057                 :      13991 :   argv[i] = NULL;
    2058                 :            : 
    2059                 :      13991 :   at_file_argbuf.truncate (0);
    2060                 :            : 
    2061                 :      13991 :   if (f == NULL)
    2062                 :          0 :     fatal_error (input_location, "could not open temporary response file %s",
    2063                 :            :                  temp_file);
    2064                 :            : 
    2065                 :      13991 :   status = writeargv (argv, f);
    2066                 :            : 
    2067                 :      13991 :   if (status)
    2068                 :          0 :     fatal_error (input_location,
    2069                 :            :                  "could not write to temporary response file %s",
    2070                 :            :                  temp_file);
    2071                 :            : 
    2072                 :      13991 :   status = fclose (f);
    2073                 :            : 
    2074                 :      13991 :   if (status == EOF)
    2075                 :          0 :     fatal_error (input_location, "could not close temporary response file %s",
    2076                 :            :                  temp_file);
    2077                 :            : 
    2078                 :      13991 :   store_arg (at_argument, 0, 0);
    2079                 :            : 
    2080                 :      13991 :   record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
    2081                 :            : }
    2082                 :            : 
    2083                 :            : /* Load specs from a file name named FILENAME, replacing occurrences of
    2084                 :            :    various different types of line-endings, \r\n, \n\r and just \r, with
    2085                 :            :    a single \n.  */
    2086                 :            : 
    2087                 :            : static char *
    2088                 :     223727 : load_specs (const char *filename)
    2089                 :            : {
    2090                 :     223727 :   int desc;
    2091                 :     223727 :   int readlen;
    2092                 :     223727 :   struct stat statbuf;
    2093                 :     223727 :   char *buffer;
    2094                 :     223727 :   char *buffer_p;
    2095                 :     223727 :   char *specs;
    2096                 :     223727 :   char *specs_p;
    2097                 :            : 
    2098                 :     223727 :   if (verbose_flag)
    2099                 :        727 :     fnotice (stderr, "Reading specs from %s\n", filename);
    2100                 :            : 
    2101                 :            :   /* Open and stat the file.  */
    2102                 :     223727 :   desc = open (filename, O_RDONLY, 0);
    2103                 :     223727 :   if (desc < 0)
    2104                 :            :     {
    2105                 :          1 :     failed:
    2106                 :            :       /* This leaves DESC open, but the OS will save us.  */
    2107                 :          1 :       fatal_error (input_location, "cannot read spec file %qs: %m", filename);
    2108                 :            :     }
    2109                 :            : 
    2110                 :     223726 :   if (stat (filename, &statbuf) < 0)
    2111                 :          0 :     goto failed;
    2112                 :            : 
    2113                 :            :   /* Read contents of file into BUFFER.  */
    2114                 :     223726 :   buffer = XNEWVEC (char, statbuf.st_size + 1);
    2115                 :     223726 :   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
    2116                 :     223726 :   if (readlen < 0)
    2117                 :          0 :     goto failed;
    2118                 :     223726 :   buffer[readlen] = 0;
    2119                 :     223726 :   close (desc);
    2120                 :            : 
    2121                 :     223726 :   specs = XNEWVEC (char, readlen + 1);
    2122                 :     223726 :   specs_p = specs;
    2123                 : 1878990000 :   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
    2124                 :            :     {
    2125                 : 1878770000 :       int skip = 0;
    2126                 : 1878770000 :       char c = *buffer_p;
    2127                 : 1878770000 :       if (c == '\r')
    2128                 :            :         {
    2129                 :          0 :           if (buffer_p > buffer && *(buffer_p - 1) == '\n')  /* \n\r */
    2130                 :            :             skip = 1;
    2131                 :          0 :           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
    2132                 :            :             skip = 1;
    2133                 :            :           else                                                  /* \r */
    2134                 :            :             c = '\n';
    2135                 :            :         }
    2136                 :            :       if (! skip)
    2137                 : 1878770000 :         *specs_p++ = c;
    2138                 :            :     }
    2139                 :     223726 :   *specs_p = '\0';
    2140                 :            : 
    2141                 :     223726 :   free (buffer);
    2142                 :     223726 :   return (specs);
    2143                 :            : }
    2144                 :            : 
    2145                 :            : /* Read compilation specs from a file named FILENAME,
    2146                 :            :    replacing the default ones.
    2147                 :            : 
    2148                 :            :    A suffix which starts with `*' is a definition for
    2149                 :            :    one of the machine-specific sub-specs.  The "suffix" should be
    2150                 :            :    *asm, *cc1, *cpp, *link, *startfile, etc.
    2151                 :            :    The corresponding spec is stored in asm_spec, etc.,
    2152                 :            :    rather than in the `compilers' vector.
    2153                 :            : 
    2154                 :            :    Anything invalid in the file is a fatal error.  */
    2155                 :            : 
    2156                 :            : static void
    2157                 :     223727 : read_specs (const char *filename, bool main_p, bool user_p)
    2158                 :            : {
    2159                 :     223727 :   char *buffer;
    2160                 :     223727 :   char *p;
    2161                 :            : 
    2162                 :     223727 :   buffer = load_specs (filename);
    2163                 :            : 
    2164                 :            :   /* Scan BUFFER for specs, putting them in the vector.  */
    2165                 :     223727 :   p = buffer;
    2166                 :    9573930 :   while (1)
    2167                 :            :     {
    2168                 :    9573930 :       char *suffix;
    2169                 :    9573930 :       char *spec;
    2170                 :    9573930 :       char *in, *out, *p1, *p2, *p3;
    2171                 :            : 
    2172                 :            :       /* Advance P in BUFFER to the next nonblank nocomment line.  */
    2173                 :    9573930 :       p = skip_whitespace (p);
    2174                 :    9573930 :       if (*p == 0)
    2175                 :            :         break;
    2176                 :            : 
    2177                 :            :       /* Is this a special command that starts with '%'? */
    2178                 :            :       /* Don't allow this for the main specs file, since it would
    2179                 :            :          encourage people to overwrite it.  */
    2180                 :    9350200 :       if (*p == '%' && !main_p)
    2181                 :            :         {
    2182                 :     348180 :           p1 = p;
    2183                 :     348180 :           while (*p && *p != '\n')
    2184                 :     330771 :             p++;
    2185                 :            : 
    2186                 :            :           /* Skip '\n'.  */
    2187                 :      17409 :           p++;
    2188                 :            : 
    2189                 :      17409 :           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
    2190                 :          0 :               && (p1[sizeof "%include" - 1] == ' '
    2191                 :          0 :                   || p1[sizeof "%include" - 1] == '\t'))
    2192                 :            :             {
    2193                 :          0 :               char *new_filename;
    2194                 :            : 
    2195                 :          0 :               p1 += sizeof ("%include");
    2196                 :          0 :               while (*p1 == ' ' || *p1 == '\t')
    2197                 :          0 :                 p1++;
    2198                 :            : 
    2199                 :          0 :               if (*p1++ != '<' || p[-2] != '>')
    2200                 :          0 :                 fatal_error (input_location,
    2201                 :            :                              "specs %%include syntax malformed after "
    2202                 :            :                              "%ld characters",
    2203                 :          0 :                              (long) (p1 - buffer + 1));
    2204                 :            : 
    2205                 :          0 :               p[-2] = '\0';
    2206                 :          0 :               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
    2207                 :          0 :               read_specs (new_filename ? new_filename : p1, false, user_p);
    2208                 :          0 :               continue;
    2209                 :            :             }
    2210                 :      17409 :           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
    2211                 :          0 :                    && (p1[sizeof "%include_noerr" - 1] == ' '
    2212                 :          0 :                        || p1[sizeof "%include_noerr" - 1] == '\t'))
    2213                 :            :             {
    2214                 :          0 :               char *new_filename;
    2215                 :            : 
    2216                 :          0 :               p1 += sizeof "%include_noerr";
    2217                 :          0 :               while (*p1 == ' ' || *p1 == '\t')
    2218                 :          0 :                 p1++;
    2219                 :            : 
    2220                 :          0 :               if (*p1++ != '<' || p[-2] != '>')
    2221                 :          0 :                 fatal_error (input_location,
    2222                 :            :                              "specs %%include syntax malformed after "
    2223                 :            :                              "%ld characters",
    2224                 :          0 :                              (long) (p1 - buffer + 1));
    2225                 :            : 
    2226                 :          0 :               p[-2] = '\0';
    2227                 :          0 :               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
    2228                 :          0 :               if (new_filename)
    2229                 :          0 :                 read_specs (new_filename, false, user_p);
    2230                 :          0 :               else if (verbose_flag)
    2231                 :          0 :                 fnotice (stderr, "could not find specs file %s\n", p1);
    2232                 :          0 :               continue;
    2233                 :            :             }
    2234                 :      17409 :           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
    2235                 :      17409 :                    && (p1[sizeof "%rename" - 1] == ' '
    2236                 :          0 :                        || p1[sizeof "%rename" - 1] == '\t'))
    2237                 :            :             {
    2238                 :      17409 :               int name_len;
    2239                 :      17409 :               struct spec_list *sl;
    2240                 :      17409 :               struct spec_list *newsl;
    2241                 :            : 
    2242                 :            :               /* Get original name.  */
    2243                 :      17409 :               p1 += sizeof "%rename";
    2244                 :      17409 :               while (*p1 == ' ' || *p1 == '\t')
    2245                 :          0 :                 p1++;
    2246                 :            : 
    2247                 :      17409 :               if (! ISALPHA ((unsigned char) *p1))
    2248                 :          0 :                 fatal_error (input_location,
    2249                 :            :                              "specs %%rename syntax malformed after "
    2250                 :            :                              "%ld characters",
    2251                 :            :                              (long) (p1 - buffer));
    2252                 :            : 
    2253                 :            :               p2 = p1;
    2254                 :      69636 :               while (*p2 && !ISSPACE ((unsigned char) *p2))
    2255                 :      52227 :                 p2++;
    2256                 :            : 
    2257                 :      17409 :               if (*p2 != ' ' && *p2 != '\t')
    2258                 :          0 :                 fatal_error (input_location,
    2259                 :            :                              "specs %%rename syntax malformed after "
    2260                 :            :                              "%ld characters",
    2261                 :            :                              (long) (p2 - buffer));
    2262                 :            : 
    2263                 :      17409 :               name_len = p2 - p1;
    2264                 :      17409 :               *p2++ = '\0';
    2265                 :      17409 :               while (*p2 == ' ' || *p2 == '\t')
    2266                 :          0 :                 p2++;
    2267                 :            : 
    2268                 :      17409 :               if (! ISALPHA ((unsigned char) *p2))
    2269                 :          0 :                 fatal_error (input_location,
    2270                 :            :                              "specs %%rename syntax malformed after "
    2271                 :            :                              "%ld characters",
    2272                 :            :                              (long) (p2 - buffer));
    2273                 :            : 
    2274                 :            :               /* Get new spec name.  */
    2275                 :            :               p3 = p2;
    2276                 :     139272 :               while (*p3 && !ISSPACE ((unsigned char) *p3))
    2277                 :     121863 :                 p3++;
    2278                 :            : 
    2279                 :      17409 :               if (p3 != p - 1)
    2280                 :          0 :                 fatal_error (input_location,
    2281                 :            :                              "specs %%rename syntax malformed after "
    2282                 :            :                              "%ld characters",
    2283                 :            :                              (long) (p3 - buffer));
    2284                 :      17409 :               *p3 = '\0';
    2285                 :            : 
    2286                 :     330771 :               for (sl = specs; sl; sl = sl->next)
    2287                 :     330771 :                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
    2288                 :            :                   break;
    2289                 :            : 
    2290                 :      17409 :               if (!sl)
    2291                 :          0 :                 fatal_error (input_location,
    2292                 :            :                              "specs %s spec was not found to be renamed", p1);
    2293                 :            : 
    2294                 :      17409 :               if (strcmp (p1, p2) == 0)
    2295                 :          0 :                 continue;
    2296                 :            : 
    2297                 :     800814 :               for (newsl = specs; newsl; newsl = newsl->next)
    2298                 :     783405 :                 if (strcmp (newsl->name, p2) == 0)
    2299                 :          0 :                   fatal_error (input_location,
    2300                 :            :                                "%s: attempt to rename spec %qs to "
    2301                 :            :                                "already defined spec %qs",
    2302                 :            :                     filename, p1, p2);
    2303                 :            : 
    2304                 :      17409 :               if (verbose_flag)
    2305                 :            :                 {
    2306                 :          0 :                   fnotice (stderr, "rename spec %s to %s\n", p1, p2);
    2307                 :            : #ifdef DEBUG_SPECS
    2308                 :            :                   fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
    2309                 :            : #endif
    2310                 :            :                 }
    2311                 :            : 
    2312                 :      17409 :               set_spec (p2, *(sl->ptr_spec), user_p);
    2313                 :      17409 :               if (sl->alloc_p)
    2314                 :      17409 :                 free (CONST_CAST (char *, *(sl->ptr_spec)));
    2315                 :            : 
    2316                 :      17409 :               *(sl->ptr_spec) = "";
    2317                 :      17409 :               sl->alloc_p = 0;
    2318                 :      17409 :               continue;
    2319                 :            :             }
    2320                 :            :           else
    2321                 :          0 :             fatal_error (input_location,
    2322                 :            :                          "specs unknown %% command after %ld characters",
    2323                 :            :                          (long) (p1 - buffer));
    2324                 :            :         }
    2325                 :            : 
    2326                 :            :       /* Find the colon that should end the suffix.  */
    2327                 :            :       p1 = p;
    2328                 :  127252000 :       while (*p1 && *p1 != ':' && *p1 != '\n')
    2329                 :  117919000 :         p1++;
    2330                 :            : 
    2331                 :            :       /* The colon shouldn't be missing.  */
    2332                 :    9332800 :       if (*p1 != ':')
    2333                 :          0 :         fatal_error (input_location,
    2334                 :            :                      "specs file malformed after %ld characters",
    2335                 :            :                      (long) (p1 - buffer));
    2336                 :            : 
    2337                 :            :       /* Skip back over trailing whitespace.  */
    2338                 :            :       p2 = p1;
    2339                 :    9332800 :       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
    2340                 :          0 :         p2--;
    2341                 :            : 
    2342                 :            :       /* Copy the suffix to a string.  */
    2343                 :    9332800 :       suffix = save_string (p, p2 - p);
    2344                 :            :       /* Find the next line.  */
    2345                 :    9332800 :       p = skip_whitespace (p1 + 1);
    2346                 :    9332800 :       if (p[1] == 0)
    2347                 :          0 :         fatal_error (input_location,
    2348                 :            :                      "specs file malformed after %ld characters",
    2349                 :            :                      (long) (p - buffer));
    2350                 :            : 
    2351                 :            :       p1 = p;
    2352                 :            :       /* Find next blank line or end of string.  */
    2353                 : 1729640000 :       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
    2354                 : 1720300000 :         p1++;
    2355                 :            : 
    2356                 :            :       /* Specs end at the blank line and do not include the newline.  */
    2357                 :    9332800 :       spec = save_string (p, p1 - p);
    2358                 :    9332800 :       p = p1;
    2359                 :            : 
    2360                 :            :       /* Delete backslash-newline sequences from the spec.  */
    2361                 :    9332800 :       in = spec;
    2362                 :    9332800 :       out = spec;
    2363                 : 1729640000 :       while (*in != 0)
    2364                 :            :         {
    2365                 : 1720300000 :           if (in[0] == '\\' && in[1] == '\n')
    2366                 :          2 :             in += 2;
    2367                 : 1720300000 :           else if (in[0] == '#')
    2368                 :          0 :             while (*in && *in != '\n')
    2369                 :          0 :               in++;
    2370                 :            : 
    2371                 :            :           else
    2372                 : 1720300000 :             *out++ = *in++;
    2373                 :            :         }
    2374                 :    9332800 :       *out = 0;
    2375                 :            : 
    2376                 :    9332800 :       if (suffix[0] == '*')
    2377                 :            :         {
    2378                 :    9332800 :           if (! strcmp (suffix, "*link_command"))
    2379                 :     202423 :             link_command_spec = spec;
    2380                 :            :           else
    2381                 :            :             {
    2382                 :    9130370 :               set_spec (suffix + 1, spec, user_p);
    2383                 :    9130370 :               free (spec);
    2384                 :            :             }
    2385                 :            :         }
    2386                 :            :       else
    2387                 :            :         {
    2388                 :            :           /* Add this pair to the vector.  */
    2389                 :          0 :           compilers
    2390                 :          0 :             = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
    2391                 :            : 
    2392                 :          0 :           compilers[n_compilers].suffix = suffix;
    2393                 :          0 :           compilers[n_compilers].spec = spec;
    2394                 :          0 :           n_compilers++;
    2395                 :          0 :           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
    2396                 :            :         }
    2397                 :            : 
    2398                 :    9332800 :       if (*suffix == 0)
    2399                 :          0 :         link_command_spec = spec;
    2400                 :            :     }
    2401                 :            : 
    2402                 :     223726 :   if (link_command_spec == 0)
    2403                 :          0 :     fatal_error (input_location, "spec file has no spec for linking");
    2404                 :            : 
    2405                 :     223726 :   XDELETEVEC (buffer);
    2406                 :     223726 : }
    2407                 :            : 
    2408                 :            : /* Record the names of temporary files we tell compilers to write,
    2409                 :            :    and delete them at the end of the run.  */
    2410                 :            : 
    2411                 :            : /* This is the common prefix we use to make temp file names.
    2412                 :            :    It is chosen once for each run of this program.
    2413                 :            :    It is substituted into a spec by %g or %j.
    2414                 :            :    Thus, all temp file names contain this prefix.
    2415                 :            :    In practice, all temp file names start with this prefix.
    2416                 :            : 
    2417                 :            :    This prefix comes from the envvar TMPDIR if it is defined;
    2418                 :            :    otherwise, from the P_tmpdir macro if that is defined;
    2419                 :            :    otherwise, in /usr/tmp or /tmp;
    2420                 :            :    or finally the current directory if all else fails.  */
    2421                 :            : 
    2422                 :            : static const char *temp_filename;
    2423                 :            : 
    2424                 :            : /* Length of the prefix.  */
    2425                 :            : 
    2426                 :            : static int temp_filename_length;
    2427                 :            : 
    2428                 :            : /* Define the list of temporary files to delete.  */
    2429                 :            : 
    2430                 :            : struct temp_file
    2431                 :            : {
    2432                 :            :   const char *name;
    2433                 :            :   struct temp_file *next;
    2434                 :            : };
    2435                 :            : 
    2436                 :            : /* Queue of files to delete on success or failure of compilation.  */
    2437                 :            : static struct temp_file *always_delete_queue;
    2438                 :            : /* Queue of files to delete on failure of compilation.  */
    2439                 :            : static struct temp_file *failure_delete_queue;
    2440                 :            : 
    2441                 :            : /* Record FILENAME as a file to be deleted automatically.
    2442                 :            :    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
    2443                 :            :    otherwise delete it in any case.
    2444                 :            :    FAIL_DELETE nonzero means delete it if a compilation step fails;
    2445                 :            :    otherwise delete it in any case.  */
    2446                 :            : 
    2447                 :            : void
    2448                 :     511903 : record_temp_file (const char *filename, int always_delete, int fail_delete)
    2449                 :            : {
    2450                 :     511903 :   char *const name = xstrdup (filename);
    2451                 :            : 
    2452                 :     511903 :   if (always_delete)
    2453                 :            :     {
    2454                 :     393983 :       struct temp_file *temp;
    2455                 :     692377 :       for (temp = always_delete_queue; temp; temp = temp->next)
    2456                 :     416310 :         if (! filename_cmp (name, temp->name))
    2457                 :            :           {
    2458                 :     117916 :             free (name);
    2459                 :     117916 :             goto already1;
    2460                 :            :           }
    2461                 :            : 
    2462                 :     276067 :       temp = XNEW (struct temp_file);
    2463                 :     276067 :       temp->next = always_delete_queue;
    2464                 :     276067 :       temp->name = name;
    2465                 :     276067 :       always_delete_queue = temp;
    2466                 :            : 
    2467                 :     511903 :     already1:;
    2468                 :            :     }
    2469                 :            : 
    2470                 :     511903 :   if (fail_delete)
    2471                 :            :     {
    2472                 :     204907 :       struct temp_file *temp;
    2473                 :     214659 :       for (temp = failure_delete_queue; temp; temp = temp->next)
    2474                 :       9757 :         if (! filename_cmp (name, temp->name))
    2475                 :            :           {
    2476                 :          5 :             free (name);
    2477                 :          5 :             goto already2;
    2478                 :            :           }
    2479                 :            : 
    2480                 :     204902 :       temp = XNEW (struct temp_file);
    2481                 :     204902 :       temp->next = failure_delete_queue;
    2482                 :     204902 :       temp->name = name;
    2483                 :     204902 :       failure_delete_queue = temp;
    2484                 :            : 
    2485                 :     511903 :     already2:;
    2486                 :            :     }
    2487                 :     511903 : }
    2488                 :            : 
    2489                 :            : /* Delete all the temporary files whose names we previously recorded.  */
    2490                 :            : 
    2491                 :            : #ifndef DELETE_IF_ORDINARY
    2492                 :            : #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
    2493                 :            : do                                                      \
    2494                 :            :   {                                                     \
    2495                 :            :     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
    2496                 :            :       if (unlink (NAME) < 0)                            \
    2497                 :            :         if (VERBOSE_FLAG)                               \
    2498                 :            :           error ("%s: %m", (NAME));                   \
    2499                 :            :   } while (0)
    2500                 :            : #endif
    2501                 :            : 
    2502                 :            : static void
    2503                 :     293458 : delete_if_ordinary (const char *name)
    2504                 :            : {
    2505                 :     293458 :   struct stat st;
    2506                 :            : #ifdef DEBUG
    2507                 :            :   int i, c;
    2508                 :            : 
    2509                 :            :   printf ("Delete %s? (y or n) ", name);
    2510                 :            :   fflush (stdout);
    2511                 :            :   i = getchar ();
    2512                 :            :   if (i != '\n')
    2513                 :            :     while ((c = getchar ()) != '\n' && c != EOF)
    2514                 :            :       ;
    2515                 :            : 
    2516                 :            :   if (i == 'y' || i == 'Y')
    2517                 :            : #endif /* DEBUG */
    2518                 :     293458 :   DELETE_IF_ORDINARY (name, st, verbose_flag);
    2519                 :     293458 : }
    2520                 :            : 
    2521                 :            : static void
    2522                 :     402772 : delete_temp_files (void)
    2523                 :            : {
    2524                 :     402772 :   struct temp_file *temp;
    2525                 :            : 
    2526                 :     678839 :   for (temp = always_delete_queue; temp; temp = temp->next)
    2527                 :     276067 :     delete_if_ordinary (temp->name);
    2528                 :     402772 :   always_delete_queue = 0;
    2529                 :     203006 : }
    2530                 :            : 
    2531                 :            : /* Delete all the files to be deleted on error.  */
    2532                 :            : 
    2533                 :            : static void
    2534                 :      43259 : delete_failure_queue (void)
    2535                 :            : {
    2536                 :      43259 :   struct temp_file *temp;
    2537                 :            : 
    2538                 :      60650 :   for (temp = failure_delete_queue; temp; temp = temp->next)
    2539                 :      17391 :     delete_if_ordinary (temp->name);
    2540                 :          0 : }
    2541                 :            : 
    2542                 :            : static void
    2543                 :     368879 : clear_failure_queue (void)
    2544                 :            : {
    2545                 :     368879 :   failure_delete_queue = 0;
    2546                 :     368879 : }
    2547                 :            : 
    2548                 :            : /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
    2549                 :            :    returns non-NULL.
    2550                 :            :    If DO_MULTI is true iterate over the paths twice, first with multilib
    2551                 :            :    suffix then without, otherwise iterate over the paths once without
    2552                 :            :    adding a multilib suffix.  When DO_MULTI is true, some attempt is made
    2553                 :            :    to avoid visiting the same path twice, but we could do better.  For
    2554                 :            :    instance, /usr/lib/../lib is considered different from /usr/lib.
    2555                 :            :    At least EXTRA_SPACE chars past the end of the path passed to
    2556                 :            :    CALLBACK are available for use by the callback.
    2557                 :            :    CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
    2558                 :            : 
    2559                 :            :    Returns the value returned by CALLBACK.  */
    2560                 :            : 
    2561                 :            : static void *
    2562                 :    2043730 : for_each_path (const struct path_prefix *paths,
    2563                 :            :                bool do_multi,
    2564                 :            :                size_t extra_space,
    2565                 :            :                void *(*callback) (char *, void *),
    2566                 :            :                void *callback_info)
    2567                 :            : {
    2568                 :    2043730 :   struct prefix_list *pl;
    2569                 :    2043730 :   const char *multi_dir = NULL;
    2570                 :    2043730 :   const char *multi_os_dir = NULL;
    2571                 :    2043730 :   const char *multiarch_suffix = NULL;
    2572                 :    2043730 :   const char *multi_suffix;
    2573                 :    2043730 :   const char *just_multi_suffix;
    2574                 :    2043730 :   char *path = NULL;
    2575                 :    2043730 :   void *ret = NULL;
    2576                 :    2043730 :   bool skip_multi_dir = false;
    2577                 :    2043730 :   bool skip_multi_os_dir = false;
    2578                 :            : 
    2579                 :    2043730 :   multi_suffix = machine_suffix;
    2580                 :    2043730 :   just_multi_suffix = just_machine_suffix;
    2581                 :    2043730 :   if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
    2582                 :            :     {
    2583                 :      12891 :       multi_dir = concat (multilib_dir, dir_separator_str, NULL);
    2584                 :      12891 :       multi_suffix = concat (multi_suffix, multi_dir, NULL);
    2585                 :      12891 :       just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
    2586                 :            :     }
    2587                 :    2043730 :   if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
    2588                 :     690378 :     multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
    2589                 :    2043730 :   if (multiarch_dir)
    2590                 :          0 :     multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
    2591                 :            : 
    2592                 :    2350210 :   while (1)
    2593                 :            :     {
    2594                 :    2350210 :       size_t multi_dir_len = 0;
    2595                 :    2350210 :       size_t multi_os_dir_len = 0;
    2596                 :    2350210 :       size_t multiarch_len = 0;
    2597                 :    2350210 :       size_t suffix_len;
    2598                 :    2350210 :       size_t just_suffix_len;
    2599                 :    2350210 :       size_t len;
    2600                 :            : 
    2601                 :    2350210 :       if (multi_dir)
    2602                 :      12891 :         multi_dir_len = strlen (multi_dir);
    2603                 :    2350210 :       if (multi_os_dir)
    2604                 :     690378 :         multi_os_dir_len = strlen (multi_os_dir);
    2605                 :    2350210 :       if (multiarch_suffix)
    2606                 :          0 :         multiarch_len = strlen (multiarch_suffix);
    2607                 :    2350210 :       suffix_len = strlen (multi_suffix);
    2608                 :    2350210 :       just_suffix_len = strlen (just_multi_suffix);
    2609                 :            : 
    2610                 :    2350210 :       if (path == NULL)
    2611                 :            :         {
    2612                 :    2043730 :           len = paths->max_len + extra_space + 1;
    2613                 :    2043730 :           len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
    2614                 :    2043730 :           path = XNEWVEC (char, len);
    2615                 :            :         }
    2616                 :            : 
    2617                 :   10021700 :       for (pl = paths->plist; pl != 0; pl = pl->next)
    2618                 :            :         {
    2619                 :    8887640 :           len = strlen (pl->prefix);
    2620                 :    8887640 :           memcpy (path, pl->prefix, len);
    2621                 :            : 
    2622                 :            :           /* Look first in MACHINE/VERSION subdirectory.  */
    2623                 :    8887640 :           if (!skip_multi_dir)
    2624                 :            :             {
    2625                 :    6559950 :               memcpy (path + len, multi_suffix, suffix_len + 1);
    2626                 :    6559950 :               ret = callback (path, callback_info);
    2627                 :    6559950 :               if (ret)
    2628                 :            :                 break;
    2629                 :            :             }
    2630                 :            : 
    2631                 :            :           /* Some paths are tried with just the machine (ie. target)
    2632                 :            :              subdir.  This is used for finding as, ld, etc.  */
    2633                 :    8887640 :           if (!skip_multi_dir
    2634                 :    6559950 :               && pl->require_machine_suffix == 2)
    2635                 :            :             {
    2636                 :          0 :               memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
    2637                 :          0 :               ret = callback (path, callback_info);
    2638                 :          0 :               if (ret)
    2639                 :            :                 break;
    2640                 :            :             }
    2641                 :            : 
    2642                 :            :           /* Now try the multiarch path.  */
    2643                 :    8887640 :           if (!skip_multi_dir
    2644                 :    6559950 :               && !pl->require_machine_suffix && multiarch_dir)
    2645                 :            :             {
    2646                 :          0 :               memcpy (path + len, multiarch_suffix, multiarch_len + 1);
    2647                 :          0 :               ret = callback (path, callback_info);
    2648                 :          0 :               if (ret)
    2649                 :            :                 break;
    2650                 :            :             }
    2651                 :            : 
    2652                 :            :           /* Now try the base path.  */
    2653                 :    8887640 :           if (!pl->require_machine_suffix
    2654                 :    8887640 :               && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
    2655                 :            :             {
    2656                 :    7856740 :               const char *this_multi;
    2657                 :    7856740 :               size_t this_multi_len;
    2658                 :            : 
    2659                 :    7856740 :               if (pl->os_multilib)
    2660                 :            :                 {
    2661                 :            :                   this_multi = multi_os_dir;
    2662                 :            :                   this_multi_len = multi_os_dir_len;
    2663                 :            :                 }
    2664                 :            :               else
    2665                 :            :                 {
    2666                 :    4321250 :                   this_multi = multi_dir;
    2667                 :    4321250 :                   this_multi_len = multi_dir_len;
    2668                 :            :                 }
    2669                 :            : 
    2670                 :    7856740 :               if (this_multi_len)
    2671                 :    2250410 :                 memcpy (path + len, this_multi, this_multi_len + 1);
    2672                 :            :               else
    2673                 :    5606340 :                 path[len] = '\0';
    2674                 :            : 
    2675                 :    7856740 :               ret = callback (path, callback_info);
    2676                 :    7856740 :               if (ret)
    2677                 :            :                 break;
    2678                 :            :             }
    2679                 :            :         }
    2680                 :    2350210 :       if (pl)
    2681                 :            :         break;
    2682                 :            : 
    2683                 :    1134060 :       if (multi_dir == NULL && multi_os_dir == NULL)
    2684                 :            :         break;
    2685                 :            : 
    2686                 :            :       /* Run through the paths again, this time without multilibs.
    2687                 :            :          Don't repeat any we have already seen.  */
    2688                 :     306478 :       if (multi_dir)
    2689                 :            :         {
    2690                 :       8199 :           free (CONST_CAST (char *, multi_dir));
    2691                 :       8199 :           multi_dir = NULL;
    2692                 :       8199 :           free (CONST_CAST (char *, multi_suffix));
    2693                 :       8199 :           multi_suffix = machine_suffix;
    2694                 :       8199 :           free (CONST_CAST (char *, just_multi_suffix));
    2695                 :       8199 :           just_multi_suffix = just_machine_suffix;
    2696                 :            :         }
    2697                 :            :       else
    2698                 :            :         skip_multi_dir = true;
    2699                 :     306478 :       if (multi_os_dir)
    2700                 :            :         {
    2701                 :     306478 :           free (CONST_CAST (char *, multi_os_dir));
    2702                 :     306478 :           multi_os_dir = NULL;
    2703                 :            :         }
    2704                 :            :       else
    2705                 :            :         skip_multi_os_dir = true;
    2706                 :            :     }
    2707                 :            : 
    2708                 :    2043730 :   if (multi_dir)
    2709                 :            :     {
    2710                 :       4692 :       free (CONST_CAST (char *, multi_dir));
    2711                 :       4692 :       free (CONST_CAST (char *, multi_suffix));
    2712                 :       4692 :       free (CONST_CAST (char *, just_multi_suffix));
    2713                 :            :     }
    2714                 :    2043730 :   if (multi_os_dir)
    2715                 :     383900 :     free (CONST_CAST (char *, multi_os_dir));
    2716                 :    2043730 :   if (ret != path)
    2717                 :     827578 :     free (path);
    2718                 :    2043730 :   return ret;
    2719                 :            : }
    2720                 :            : 
    2721                 :            : /* Callback for build_search_list.  Adds path to obstack being built.  */
    2722                 :            : 
    2723                 :            : struct add_to_obstack_info {
    2724                 :            :   struct obstack *ob;
    2725                 :            :   bool check_dir;
    2726                 :            :   bool first_time;
    2727                 :            : };
    2728                 :            : 
    2729                 :            : static void *
    2730                 :    5047050 : add_to_obstack (char *path, void *data)
    2731                 :            : {
    2732                 :    5047050 :   struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
    2733                 :            : 
    2734                 :    5047050 :   if (info->check_dir && !is_directory (path, false))
    2735                 :            :     return NULL;
    2736                 :            : 
    2737                 :    1854690 :   if (!info->first_time)
    2738                 :    1499890 :     obstack_1grow (info->ob, PATH_SEPARATOR);
    2739                 :            : 
    2740                 :    1854690 :   obstack_grow (info->ob, path, strlen (path));
    2741                 :            : 
    2742                 :    1854690 :   info->first_time = false;
    2743                 :    1854690 :   return NULL;
    2744                 :            : }
    2745                 :            : 
    2746                 :            : /* Add or change the value of an environment variable, outputting the
    2747                 :            :    change to standard error if in verbose mode.  */
    2748                 :            : static void
    2749                 :    1390300 : xputenv (const char *string)
    2750                 :            : {
    2751                 :          0 :   env.xput (string);
    2752                 :     247090 : }
    2753                 :            : 
    2754                 :            : /* Build a list of search directories from PATHS.
    2755                 :            :    PREFIX is a string to prepend to the list.
    2756                 :            :    If CHECK_DIR_P is true we ensure the directory exists.
    2757                 :            :    If DO_MULTI is true, multilib paths are output first, then
    2758                 :            :    non-multilib paths.
    2759                 :            :    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
    2760                 :            :    It is also used by the --print-search-dirs flag.  */
    2761                 :            : 
    2762                 :            : static char *
    2763                 :     355648 : build_search_list (const struct path_prefix *paths, const char *prefix,
    2764                 :            :                    bool check_dir, bool do_multi)
    2765                 :            : {
    2766                 :     355648 :   struct add_to_obstack_info info;
    2767                 :            : 
    2768                 :     355648 :   info.ob = &collect_obstack;
    2769                 :     355648 :   info.check_dir = check_dir;
    2770                 :     355648 :   info.first_time = true;
    2771                 :            : 
    2772                 :     355648 :   obstack_grow (&collect_obstack, prefix, strlen (prefix));
    2773                 :     355648 :   obstack_1grow (&collect_obstack, '=');
    2774                 :            : 
    2775                 :     355648 :   for_each_path (paths, do_multi, 0, add_to_obstack, &info);
    2776                 :            : 
    2777                 :     355648 :   obstack_1grow (&collect_obstack, '\0');
    2778                 :     355648 :   return XOBFINISH (&collect_obstack, char *);
    2779                 :            : }
    2780                 :            : 
    2781                 :            : /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
    2782                 :            :    for collect.  */
    2783                 :            : 
    2784                 :            : static void
    2785                 :     355600 : putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
    2786                 :            :                       bool do_multi)
    2787                 :            : {
    2788                 :     355600 :   xputenv (build_search_list (paths, env_var, true, do_multi));
    2789                 :     355600 : }
    2790                 :            : 
    2791                 :            : /* Check whether NAME can be accessed in MODE.  This is like access,
    2792                 :            :    except that it never considers directories to be executable.  */
    2793                 :            : 
    2794                 :            : static int
    2795                 :    6858310 : access_check (const char *name, int mode)
    2796                 :            : {
    2797                 :    6858310 :   if (mode == X_OK)
    2798                 :            :     {
    2799                 :    1084690 :       struct stat st;
    2800                 :            : 
    2801                 :    1084690 :       if (stat (name, &st) < 0
    2802                 :    1084690 :           || S_ISDIR (st.st_mode))
    2803                 :     550062 :         return -1;
    2804                 :            :     }
    2805                 :            : 
    2806                 :    6308250 :   return access (name, mode);
    2807                 :            : }
    2808                 :            : 
    2809                 :            : /* Callback for find_a_file.  Appends the file name to the directory
    2810                 :            :    path.  If the resulting file exists in the right mode, return the
    2811                 :            :    full pathname to the file.  */
    2812                 :            : 
    2813                 :            : struct file_at_path_info {
    2814                 :            :   const char *name;
    2815                 :            :   const char *suffix;
    2816                 :            :   int name_len;
    2817                 :            :   int suffix_len;
    2818                 :            :   int mode;
    2819                 :            : };
    2820                 :            : 
    2821                 :            : static void *
    2822                 :    6858310 : file_at_path (char *path, void *data)
    2823                 :            : {
    2824                 :    6858310 :   struct file_at_path_info *info = (struct file_at_path_info *) data;
    2825                 :    6858310 :   size_t len = strlen (path);
    2826                 :            : 
    2827                 :    6858310 :   memcpy (path + len, info->name, info->name_len);
    2828                 :    6858310 :   len += info->name_len;
    2829                 :            : 
    2830                 :            :   /* Some systems have a suffix for executable files.
    2831                 :            :      So try appending that first.  */
    2832                 :    6858310 :   if (info->suffix_len)
    2833                 :            :     {
    2834                 :          0 :       memcpy (path + len, info->suffix, info->suffix_len + 1);
    2835                 :          0 :       if (access_check (path, info->mode) == 0)
    2836                 :            :         return path;
    2837                 :            :     }
    2838                 :            : 
    2839                 :    6858310 :   path[len] = '\0';
    2840                 :    6858310 :   if (access_check (path, info->mode) == 0)
    2841                 :    1216150 :     return path;
    2842                 :            : 
    2843                 :            :   return NULL;
    2844                 :            : }
    2845                 :            : 
    2846                 :            : /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
    2847                 :            :    access to check permissions.  If DO_MULTI is true, search multilib
    2848                 :            :    paths then non-multilib paths, otherwise do not search multilib paths.
    2849                 :            :    Return 0 if not found, otherwise return its name, allocated with malloc.  */
    2850                 :            : 
    2851                 :            : static char *
    2852                 :    1295840 : find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
    2853                 :            :              bool do_multi)
    2854                 :            : {
    2855                 :    1295840 :   struct file_at_path_info info;
    2856                 :            : 
    2857                 :            : #ifdef DEFAULT_ASSEMBLER
    2858                 :            :   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
    2859                 :            :     return xstrdup (DEFAULT_ASSEMBLER);
    2860                 :            : #endif
    2861                 :            : 
    2862                 :            : #ifdef DEFAULT_LINKER
    2863                 :            :   if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0)
    2864                 :            :     return xstrdup (DEFAULT_LINKER);
    2865                 :            : #endif
    2866                 :            : 
    2867                 :            :   /* Determine the filename to execute (special case for absolute paths).  */
    2868                 :            : 
    2869                 :    1295840 :   if (IS_ABSOLUTE_PATH (name))
    2870                 :            :     {
    2871                 :          1 :       if (access (name, mode) == 0)
    2872                 :          1 :         return xstrdup (name);
    2873                 :            : 
    2874                 :            :       return NULL;
    2875                 :            :     }
    2876                 :            : 
    2877                 :    1295830 :   info.name = name;
    2878                 :    1295830 :   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
    2879                 :    1295830 :   info.name_len = strlen (info.name);
    2880                 :    1295830 :   info.suffix_len = strlen (info.suffix);
    2881                 :    1295830 :   info.mode = mode;
    2882                 :            : 
    2883                 :    1295830 :   return (char*) for_each_path (pprefix, do_multi,
    2884                 :            :                                 info.name_len + info.suffix_len,
    2885                 :    1295830 :                                 file_at_path, &info);
    2886                 :            : }
    2887                 :            : 
    2888                 :            : /* Ranking of prefixes in the sort list. -B prefixes are put before
    2889                 :            :    all others.  */
    2890                 :            : 
    2891                 :            : enum path_prefix_priority
    2892                 :            : {
    2893                 :            :   PREFIX_PRIORITY_B_OPT,
    2894                 :            :   PREFIX_PRIORITY_LAST
    2895                 :            : };
    2896                 :            : 
    2897                 :            : /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
    2898                 :            :    order according to PRIORITY.  Within each PRIORITY, new entries are
    2899                 :            :    appended.
    2900                 :            : 
    2901                 :            :    If WARN is nonzero, we will warn if no file is found
    2902                 :            :    through this prefix.  WARN should point to an int
    2903                 :            :    which will be set to 1 if this entry is used.
    2904                 :            : 
    2905                 :            :    COMPONENT is the value to be passed to update_path.
    2906                 :            : 
    2907                 :            :    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
    2908                 :            :    the complete value of machine_suffix.
    2909                 :            :    2 means try both machine_suffix and just_machine_suffix.  */
    2910                 :            : 
    2911                 :            : static void
    2912                 :    2802320 : add_prefix (struct path_prefix *pprefix, const char *prefix,
    2913                 :            :             const char *component, /* enum prefix_priority */ int priority,
    2914                 :            :             int require_machine_suffix, int os_multilib)
    2915                 :            : {
    2916                 :    2802320 :   struct prefix_list *pl, **prev;
    2917                 :    2802320 :   int len;
    2918                 :            : 
    2919                 :    2802320 :   for (prev = &pprefix->plist;
    2920                 :    9105720 :        (*prev) != NULL && (*prev)->priority <= priority;
    2921                 :    6303400 :        prev = &(*prev)->next)
    2922                 :            :     ;
    2923                 :            : 
    2924                 :            :   /* Keep track of the longest prefix.  */
    2925                 :            : 
    2926                 :    2802320 :   prefix = update_path (prefix, component);
    2927                 :    2802320 :   len = strlen (prefix);
    2928                 :    2802320 :   if (len > pprefix->max_len)
    2929                 :    1341410 :     pprefix->max_len = len;
    2930                 :            : 
    2931                 :    2802320 :   pl = XNEW (struct prefix_list);
    2932                 :    2802320 :   pl->prefix = prefix;
    2933                 :    2802320 :   pl->require_machine_suffix = require_machine_suffix;
    2934                 :    2802320 :   pl->priority = priority;
    2935                 :    2802320 :   pl->os_multilib = os_multilib;
    2936                 :            : 
    2937                 :            :   /* Insert after PREV.  */
    2938                 :    2802320 :   pl->next = (*prev);
    2939                 :    2802320 :   (*prev) = pl;
    2940                 :    2802320 : }
    2941                 :            : 
    2942                 :            : /* Same as add_prefix, but prepending target_system_root to prefix.  */
    2943                 :            : /* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
    2944                 :            : static void
    2945                 :     405472 : add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
    2946                 :            :                       const char *component,
    2947                 :            :                       /* enum prefix_priority */ int priority,
    2948                 :            :                       int require_machine_suffix, int os_multilib)
    2949                 :            : {
    2950                 :     405472 :   if (!IS_ABSOLUTE_PATH (prefix))
    2951                 :          0 :     fatal_error (input_location, "system path %qs is not absolute", prefix);
    2952                 :            : 
    2953                 :     405472 :   if (target_system_root)
    2954                 :            :     {
    2955                 :          0 :       char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
    2956                 :          0 :       size_t sysroot_len = strlen (target_system_root);
    2957                 :            : 
    2958                 :          0 :       if (sysroot_len > 0
    2959                 :          0 :           && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
    2960                 :          0 :         sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
    2961                 :            : 
    2962                 :          0 :       if (target_sysroot_suffix)
    2963                 :          0 :         prefix = concat (sysroot_no_trailing_dir_separator,
    2964                 :            :                          target_sysroot_suffix, prefix, NULL);
    2965                 :            :       else
    2966                 :          0 :         prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
    2967                 :            : 
    2968                 :          0 :       free (sysroot_no_trailing_dir_separator);
    2969                 :            : 
    2970                 :            :       /* We have to override this because GCC's notion of sysroot
    2971                 :            :          moves along with GCC.  */
    2972                 :          0 :       component = "GCC";
    2973                 :            :     }
    2974                 :            : 
    2975                 :     405472 :   add_prefix (pprefix, prefix, component, priority,
    2976                 :            :               require_machine_suffix, os_multilib);
    2977                 :     405472 : }
    2978                 :            : 
    2979                 :            : /* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix.  */
    2980                 :            : 
    2981                 :            : static void
    2982                 :      25195 : add_sysrooted_hdrs_prefix (struct path_prefix *pprefix, const char *prefix,
    2983                 :            :                            const char *component,
    2984                 :            :                            /* enum prefix_priority */ int priority,
    2985                 :            :                            int require_machine_suffix, int os_multilib)
    2986                 :            : {
    2987                 :      25195 :   if (!IS_ABSOLUTE_PATH (prefix))
    2988                 :          0 :     fatal_error (input_location, "system path %qs is not absolute", prefix);
    2989                 :            : 
    2990                 :      25195 :   if (target_system_root)
    2991                 :            :     {
    2992                 :          0 :       char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
    2993                 :          0 :       size_t sysroot_len = strlen (target_system_root);
    2994                 :            : 
    2995                 :          0 :       if (sysroot_len > 0
    2996                 :          0 :           && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
    2997                 :          0 :         sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
    2998                 :            : 
    2999                 :          0 :       if (target_sysroot_hdrs_suffix)
    3000                 :          0 :         prefix = concat (sysroot_no_trailing_dir_separator,
    3001                 :            :                          target_sysroot_hdrs_suffix, prefix, NULL);
    3002                 :            :       else
    3003                 :          0 :         prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
    3004                 :            : 
    3005                 :          0 :       free (sysroot_no_trailing_dir_separator);
    3006                 :            : 
    3007                 :            :       /* We have to override this because GCC's notion of sysroot
    3008                 :            :          moves along with GCC.  */
    3009                 :          0 :       component = "GCC";
    3010                 :            :     }
    3011                 :            : 
    3012                 :      25195 :   add_prefix (pprefix, prefix, component, priority,
    3013                 :            :               require_machine_suffix, os_multilib);
    3014                 :      25195 : }
    3015                 :            : 
    3016                 :            : 
    3017                 :            : /* Execute the command specified by the arguments on the current line of spec.
    3018                 :            :    When using pipes, this includes several piped-together commands
    3019                 :            :    with `|' between them.
    3020                 :            : 
    3021                 :            :    Return 0 if successful, -1 if failed.  */
    3022                 :            : 
    3023                 :            : static int
    3024                 :     389715 : execute (void)
    3025                 :            : {
    3026                 :     389715 :   int i;
    3027                 :     389715 :   int n_commands;               /* # of command.  */
    3028                 :     389715 :   char *string;
    3029                 :     389715 :   struct pex_obj *pex;
    3030                 :     389715 :   struct command
    3031                 :            :   {
    3032                 :            :     const char *prog;           /* program name.  */
    3033                 :            :     const char **argv;          /* vector of args.  */
    3034                 :            :   };
    3035                 :     389715 :   const char *arg;
    3036                 :            : 
    3037                 :     389715 :   struct command *commands;     /* each command buffer with above info.  */
    3038                 :            : 
    3039                 :     389715 :   gcc_assert (!processing_spec_function);
    3040                 :            : 
    3041                 :     389715 :   if (wrapper_string)
    3042                 :            :     {
    3043                 :          0 :       string = find_a_file (&exec_prefixes,
    3044                 :          0 :                             argbuf[0], X_OK, false);
    3045                 :          0 :       if (string)
    3046                 :          0 :         argbuf[0] = string;
    3047                 :          0 :       insert_wrapper (wrapper_string);
    3048                 :            :     }
    3049                 :            : 
    3050                 :            :   /* Count # of piped commands.  */
    3051                 :   10957200 :   for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
    3052                 :   10567400 :     if (strcmp (arg, "|") == 0)
    3053                 :          0 :       n_commands++;
    3054                 :            : 
    3055                 :            :   /* Get storage for each command.  */
    3056                 :     389715 :   commands = (struct command *) alloca (n_commands * sizeof (struct command));
    3057                 :            : 
    3058                 :            :   /* Split argbuf into its separate piped processes,
    3059                 :            :      and record info about each one.
    3060                 :            :      Also search for the programs that are to be run.  */
    3061                 :            : 
    3062                 :     389715 :   argbuf.safe_push (0);
    3063                 :            : 
    3064                 :     389715 :   commands[0].prog = argbuf[0]; /* first command.  */
    3065                 :     389715 :   commands[0].argv = argbuf.address ();
    3066                 :            : 
    3067                 :     389715 :   if (!wrapper_string)
    3068                 :            :     {
    3069                 :     389715 :       string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
    3070                 :     389715 :       if (string)
    3071                 :     388012 :         commands[0].argv[0] = string;
    3072                 :            :     }
    3073                 :            : 
    3074                 :   11346900 :   for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
    3075                 :   10957200 :     if (arg && strcmp (arg, "|") == 0)
    3076                 :            :       {                         /* each command.  */
    3077                 :            : #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
    3078                 :            :         fatal_error (input_location, "%<-pipe%> not supported");
    3079                 :            : #endif
    3080                 :          0 :         argbuf[i] = 0; /* Termination of command args.  */
    3081                 :          0 :         commands[n_commands].prog = argbuf[i + 1];
    3082                 :          0 :         commands[n_commands].argv
    3083                 :          0 :           = &(argbuf.address ())[i + 1];
    3084                 :          0 :         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
    3085                 :            :                               X_OK, false);
    3086                 :          0 :         if (string)
    3087                 :          0 :           commands[n_commands].argv[0] = string;
    3088                 :          0 :         n_commands++;
    3089                 :            :       }
    3090                 :            : 
    3091                 :            :   /* If -v, print what we are about to do, and maybe query.  */
    3092                 :            : 
    3093                 :     389715 :   if (verbose_flag)
    3094                 :            :     {
    3095                 :            :       /* For help listings, put a blank line between sub-processes.  */
    3096                 :       1090 :       if (print_help_list)
    3097                 :          9 :         fputc ('\n', stderr);
    3098                 :            : 
    3099                 :            :       /* Print each piped command as a separate line.  */
    3100                 :       2180 :       for (i = 0; i < n_commands; i++)
    3101                 :            :         {
    3102                 :       1090 :           const char *const *j;
    3103                 :            : 
    3104                 :       1090 :           if (verbose_only_flag)
    3105                 :            :             {
    3106                 :      12688 :               for (j = commands[i].argv; *j; j++)
    3107                 :            :                 {
    3108                 :            :                   const char *p;
    3109                 :     413755 :                   for (p = *j; *p; ++p)
    3110                 :     403621 :                     if (!ISALNUM ((unsigned char) *p)
    3111                 :      79621 :                         && *p != '_' && *p != '/' && *p != '-' && *p != '.')
    3112                 :            :                       break;
    3113                 :      11968 :                   if (*p || !*j)
    3114                 :            :                     {
    3115                 :       1834 :                       fprintf (stderr, " \"");
    3116                 :     125762 :                       for (p = *j; *p; ++p)
    3117                 :            :                         {
    3118                 :     123928 :                           if (*p == '"' || *p == '\\' || *p == '$')
    3119                 :          0 :                             fputc ('\\', stderr);
    3120                 :     123928 :                           fputc (*p, stderr);
    3121                 :            :                         }
    3122                 :       1834 :                       fputc ('"', stderr);
    3123                 :            :                     }
    3124                 :            :                   /* If it's empty, print "".  */
    3125                 :      10134 :                   else if (!**j)
    3126                 :          0 :                     fprintf (stderr, " \"\"");
    3127                 :            :                   else
    3128                 :      10134 :                     fprintf (stderr, " %s", *j);
    3129                 :            :                 }
    3130                 :            :             }
    3131                 :            :           else
    3132                 :       9505 :             for (j = commands[i].argv; *j; j++)
    3133                 :            :               /* If it's empty, print "".  */
    3134                 :       9135 :               if (!**j)
    3135                 :          0 :                 fprintf (stderr, " \"\"");
    3136                 :            :               else
    3137                 :       9135 :                 fprintf (stderr, " %s", *j);
    3138                 :            : 
    3139                 :            :           /* Print a pipe symbol after all but the last command.  */
    3140                 :       1090 :           if (i + 1 != n_commands)
    3141                 :          0 :             fprintf (stderr, " |");
    3142                 :       1090 :           fprintf (stderr, "\n");
    3143                 :            :         }
    3144                 :       1090 :       fflush (stderr);
    3145                 :       1090 :       if (verbose_only_flag != 0)
    3146                 :            :         {
    3147                 :            :           /* verbose_only_flag should act as if the spec was
    3148                 :            :              executed, so increment execution_count before
    3149                 :            :              returning.  This prevents spurious warnings about
    3150                 :            :              unused linker input files, etc.  */
    3151                 :        720 :           execution_count++;
    3152                 :        720 :           return 0;
    3153                 :            :         }
    3154                 :            : #ifdef DEBUG
    3155                 :            :       fnotice (stderr, "\nGo ahead? (y or n) ");
    3156                 :            :       fflush (stderr);
    3157                 :            :       i = getchar ();
    3158                 :            :       if (i != '\n')
    3159                 :            :         while (getchar () != '\n')
    3160                 :            :           ;
    3161                 :            : 
    3162                 :            :       if (i != 'y' && i != 'Y')
    3163                 :            :         return 0;
    3164                 :            : #endif /* DEBUG */
    3165                 :            :     }
    3166                 :            : 
    3167                 :            : #ifdef ENABLE_VALGRIND_CHECKING
    3168                 :            :   /* Run the each command through valgrind.  To simplify prepending the
    3169                 :            :      path to valgrind and the option "-q" (for quiet operation unless
    3170                 :            :      something triggers), we allocate a separate argv array.  */
    3171                 :            : 
    3172                 :            :   for (i = 0; i < n_commands; i++)
    3173                 :            :     {
    3174                 :            :       const char **argv;
    3175                 :            :       int argc;
    3176                 :            :       int j;
    3177                 :            : 
    3178                 :            :       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
    3179                 :            :         ;
    3180                 :            : 
    3181                 :            :       argv = XALLOCAVEC (const char *, argc + 3);
    3182                 :            : 
    3183                 :            :       argv[0] = VALGRIND_PATH;
    3184                 :            :       argv[1] = "-q";
    3185                 :            :       for (j = 2; j < argc + 2; j++)
    3186                 :            :         argv[j] = commands[i].argv[j - 2];
    3187                 :            :       argv[j] = NULL;
    3188                 :            : 
    3189                 :            :       commands[i].argv = argv;
    3190                 :            :       commands[i].prog = argv[0];
    3191                 :            :     }
    3192                 :            : #endif
    3193                 :            : 
    3194                 :            :   /* Run each piped subprocess.  */
    3195                 :            : 
    3196                 :     388995 :   pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
    3197                 :            :                                    ? PEX_RECORD_TIMES : 0),
    3198                 :            :                   progname, temp_filename);
    3199                 :     388995 :   if (pex == NULL)
    3200                 :            :     fatal_error (input_location, "%<pex_init%> failed: %m");
    3201                 :            : 
    3202                 :     777990 :   for (i = 0; i < n_commands; i++)
    3203                 :            :     {
    3204                 :     388995 :       const char *errmsg;
    3205                 :     388995 :       int err;
    3206                 :     388995 :       const char *string = commands[i].argv[0];
    3207                 :            : 
    3208                 :     388995 :       errmsg = pex_run (pex,
    3209                 :     388995 :                         ((i + 1 == n_commands ? PEX_LAST : 0)
    3210                 :     388995 :                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
    3211                 :            :                         string, CONST_CAST (char **, commands[i].argv),
    3212                 :            :                         NULL, NULL, &err);
    3213                 :     388995 :       if (errmsg != NULL)
    3214                 :            :         {
    3215                 :          0 :           errno = err;
    3216                 :          0 :           fatal_error (input_location,
    3217                 :            :                        err ? G_("cannot execute %qs: %s: %m")
    3218                 :            :                        : G_("cannot execute %qs: %s"),
    3219                 :            :                        string, errmsg);
    3220                 :            :         }
    3221                 :            : 
    3222                 :     388995 :       if (i && string != commands[i].prog)
    3223                 :          0 :         free (CONST_CAST (char *, string));
    3224                 :            :     }
    3225                 :            : 
    3226                 :     388995 :   execution_count++;
    3227                 :            : 
    3228                 :            :   /* Wait for all the subprocesses to finish.  */
    3229                 :            : 
    3230                 :     388995 :   {
    3231                 :     388995 :     int *statuses;
    3232                 :     388995 :     struct pex_time *times = NULL;
    3233                 :     388995 :     int ret_code = 0;
    3234                 :            : 
    3235                 :     388995 :     statuses = (int *) alloca (n_commands * sizeof (int));
    3236                 :     388995 :     if (!pex_get_status (pex, n_commands, statuses))
    3237                 :          0 :       fatal_error (input_location, "failed to get exit status: %m");
    3238                 :            : 
    3239                 :     388995 :     if (report_times || report_times_to_file)
    3240                 :            :       {
    3241                 :          0 :         times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
    3242                 :          0 :         if (!pex_get_times (pex, n_commands, times))
    3243                 :          0 :           fatal_error (input_location, "failed to get process times: %m");
    3244                 :            :       }
    3245                 :            : 
    3246                 :     388995 :     pex_free (pex);
    3247                 :            : 
    3248                 :     777990 :     for (i = 0; i < n_commands; ++i)
    3249                 :            :       {
    3250                 :     388995 :         int status = statuses[i];
    3251                 :            : 
    3252                 :     388995 :         if (WIFSIGNALED (status))
    3253                 :          0 :           switch (WTERMSIG (status))
    3254                 :            :             {
    3255                 :          0 :             case SIGINT:
    3256                 :          0 :             case SIGTERM:
    3257                 :            :               /* SIGQUIT and SIGKILL are not available on MinGW.  */
    3258                 :            : #ifdef SIGQUIT
    3259                 :          0 :             case SIGQUIT:
    3260                 :            : #endif
    3261                 :            : #ifdef SIGKILL
    3262                 :          0 :             case SIGKILL:
    3263                 :            : #endif
    3264                 :            :               /* The user (or environment) did something to the
    3265                 :            :                  inferior.  Making this an ICE confuses the user into
    3266                 :            :                  thinking there's a compiler bug.  Much more likely is
    3267                 :            :                  the user or OOM killer nuked it.  */
    3268                 :          0 :               fatal_error (input_location,
    3269                 :            :                            "%s signal terminated program %s",
    3270                 :            :                            strsignal (WTERMSIG (status)),
    3271                 :          0 :                            commands[i].prog);
    3272                 :          0 :               break;
    3273                 :            : 
    3274                 :            : #ifdef SIGPIPE
    3275                 :          0 :             case SIGPIPE:
    3276                 :            :               /* SIGPIPE is a special case.  It happens in -pipe mode
    3277                 :            :                  when the compiler dies before the preprocessor is
    3278                 :            :                  done, or the assembler dies before the compiler is
    3279                 :            :                  done.  There's generally been an error already, and
    3280                 :            :                  this is just fallout.  So don't generate another
    3281                 :            :                  error unless we would otherwise have succeeded.  */
    3282                 :          0 :               if (signal_count || greatest_status >= MIN_FATAL_STATUS)
    3283                 :            :                 {
    3284                 :          0 :                   signal_count++;
    3285                 :          0 :                   ret_code = -1;
    3286                 :          0 :                   break;
    3287                 :            :                 }
    3288                 :            : #endif
    3289                 :            :               /* FALLTHROUGH */
    3290                 :            : 
    3291                 :          0 :             default:
    3292                 :            :               /* The inferior failed to catch the signal.  */
    3293                 :          0 :               internal_error_no_backtrace ("%s signal terminated program %s",
    3294                 :            :                                            strsignal (WTERMSIG (status)),
    3295                 :          0 :                                            commands[i].prog);
    3296                 :            :             }
    3297                 :     388995 :         else if (WIFEXITED (status)
    3298                 :     388995 :                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
    3299                 :            :           {
    3300                 :            :             /* For ICEs in cc1, cc1obj, cc1plus see if it is
    3301                 :            :                reproducible or not.  */
    3302                 :      21693 :             const char *p;
    3303                 :      21693 :             if (flag_report_bug
    3304                 :          0 :                 && WEXITSTATUS (status) == ICE_EXIT_CODE
    3305                 :          0 :                 && i == 0
    3306                 :          0 :                 && (p = strrchr (commands[0].argv[0], DIR_SEPARATOR))
    3307                 :      21693 :                 && ! strncmp (p + 1, "cc1", 3))
    3308                 :          0 :               try_generate_repro (commands[0].argv);
    3309                 :      21693 :             if (WEXITSTATUS (status) > greatest_status)
    3310                 :          0 :               greatest_status = WEXITSTATUS (status);
    3311                 :            :             ret_code = -1;
    3312                 :            :           }
    3313                 :            : 
    3314                 :     388995 :         if (report_times || report_times_to_file)
    3315                 :            :           {
    3316                 :          0 :             struct pex_time *pt = &times[i];
    3317                 :          0 :             double ut, st;
    3318                 :            : 
    3319                 :          0 :             ut = ((double) pt->user_seconds
    3320                 :          0 :                   + (double) pt->user_microseconds / 1.0e6);
    3321                 :          0 :             st = ((double) pt->system_seconds
    3322                 :          0 :                   + (double) pt->system_microseconds / 1.0e6);
    3323                 :            : 
    3324                 :          0 :             if (ut + st != 0)
    3325                 :            :               {
    3326                 :          0 :                 if (report_times)
    3327                 :          0 :                   fnotice (stderr, "# %s %.2f %.2f\n",
    3328                 :          0 :                            commands[i].prog, ut, st);
    3329                 :            : 
    3330                 :          0 :                 if (report_times_to_file)
    3331                 :            :                   {
    3332                 :          0 :                     int c = 0;
    3333                 :          0 :                     const char *const *j;
    3334                 :            : 
    3335                 :          0 :                     fprintf (report_times_to_file, "%g %g", ut, st);
    3336                 :            : 
    3337                 :          0 :                     for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
    3338                 :            :                       {
    3339                 :            :                         const char *p;
    3340                 :          0 :                         for (p = *j; *p; ++p)
    3341                 :          0 :                           if (*p == '"' || *p == '\\' || *p == '$'
    3342                 :          0 :                               || ISSPACE (*p))
    3343                 :            :                             break;
    3344                 :            : 
    3345                 :          0 :                         if (*p)
    3346                 :            :                           {
    3347                 :          0 :                             fprintf (report_times_to_file, " \"");
    3348                 :          0 :                             for (p = *j; *p; ++p)
    3349                 :            :                               {
    3350                 :          0 :                                 if (*p == '"' || *p == '\\' || *p == '$')
    3351                 :          0 :                                   fputc ('\\', report_times_to_file);
    3352                 :          0 :                                 fputc (*p, report_times_to_file);
    3353                 :            :                               }
    3354                 :          0 :                             fputc ('"', report_times_to_file);
    3355                 :            :                           }
    3356                 :            :                         else
    3357                 :          0 :                           fprintf (report_times_to_file, " %s", *j);
    3358                 :            :                       }
    3359                 :            : 
    3360                 :          0 :                     fputc ('\n', report_times_to_file);
    3361                 :            :                   }
    3362                 :            :               }
    3363                 :            :           }
    3364                 :            :       }
    3365                 :            : 
    3366                 :     388995 :    if (commands[0].argv[0] != commands[0].prog)
    3367                 :     387292 :      free (CONST_CAST (char *, commands[0].argv[0]));
    3368                 :            : 
    3369                 :            :     return ret_code;
    3370                 :            :   }
    3371                 :            : }
    3372                 :            : 
    3373                 :            : /* Find all the switches given to us
    3374                 :            :    and make a vector describing them.
    3375                 :            :    The elements of the vector are strings, one per switch given.
    3376                 :            :    If a switch uses following arguments, then the `part1' field
    3377                 :            :    is the switch itself and the `args' field
    3378                 :            :    is a null-terminated vector containing the following arguments.
    3379                 :            :    Bits in the `live_cond' field are:
    3380                 :            :    SWITCH_LIVE to indicate this switch is true in a conditional spec.
    3381                 :            :    SWITCH_FALSE to indicate this switch is overridden by a later switch.
    3382                 :            :    SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
    3383                 :            :    SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
    3384                 :            :    SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
    3385                 :            :    should be included in COLLECT_GCC_OPTIONS.
    3386                 :            :    in all do_spec calls afterwards.  Used for %<S from self specs.
    3387                 :            :    The `known' field describes whether this is an internal switch.
    3388                 :            :    The `validated' field describes whether any spec has looked at this switch;
    3389                 :            :    if it remains false at the end of the run, the switch must be meaningless.
    3390                 :            :    The `ordering' field is used to temporarily mark switches that have to be
    3391                 :            :    kept in a specific order.  */
    3392                 :            : 
    3393                 :            : #define SWITCH_LIVE                     (1 << 0)
    3394                 :            : #define SWITCH_FALSE                    (1 << 1)
    3395                 :            : #define SWITCH_IGNORE                   (1 << 2)
    3396                 :            : #define SWITCH_IGNORE_PERMANENTLY       (1 << 3)
    3397                 :            : #define SWITCH_KEEP_FOR_GCC             (1 << 4)
    3398                 :            : 
    3399                 :            : struct switchstr
    3400                 :            : {
    3401                 :            :   const char *part1;
    3402                 :            :   const char **args;
    3403                 :            :   unsigned int live_cond;
    3404                 :            :   bool known;
    3405                 :            :   bool validated;
    3406                 :            :   bool ordering;
    3407                 :            : };
    3408                 :            : 
    3409                 :            : static struct switchstr *switches;
    3410                 :            : 
    3411                 :            : static int n_switches;
    3412                 :            : 
    3413                 :            : static int n_switches_alloc;
    3414                 :            : 
    3415                 :            : /* Set to zero if -fcompare-debug is disabled, positive if it's
    3416                 :            :    enabled and we're running the first compilation, negative if it's
    3417                 :            :    enabled and we're running the second compilation.  For most of the
    3418                 :            :    time, it's in the range -1..1, but it can be temporarily set to 2
    3419                 :            :    or 3 to indicate that the -fcompare-debug flags didn't come from
    3420                 :            :    the command-line, but rather from the GCC_COMPARE_DEBUG environment
    3421                 :            :    variable, until a synthesized -fcompare-debug flag is added to the
    3422                 :            :    command line.  */
    3423                 :            : int compare_debug;
    3424                 :            : 
    3425                 :            : /* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
    3426                 :            : int compare_debug_second;
    3427                 :            : 
    3428                 :            : /* Set to the flags that should be passed to the second compilation in
    3429                 :            :    a -fcompare-debug compilation.  */
    3430                 :            : const char *compare_debug_opt;
    3431                 :            : 
    3432                 :            : static struct switchstr *switches_debug_check[2];
    3433                 :            : 
    3434                 :            : static int n_switches_debug_check[2];
    3435                 :            : 
    3436                 :            : static int n_switches_alloc_debug_check[2];
    3437                 :            : 
    3438                 :            : static char *debug_check_temp_file[2];
    3439                 :            : 
    3440                 :            : /* Language is one of three things:
    3441                 :            : 
    3442                 :            :    1) The name of a real programming language.
    3443                 :            :    2) NULL, indicating that no one has figured out
    3444                 :            :    what it is yet.
    3445                 :            :    3) '*', indicating that the file should be passed
    3446                 :            :    to the linker.  */
    3447                 :            : struct infile
    3448                 :            : {
    3449                 :            :   const char *name;
    3450                 :            :   const char *language;
    3451                 :            :   struct compiler *incompiler;
    3452                 :            :   bool compiled;
    3453                 :            :   bool preprocessed;
    3454                 :            : };
    3455                 :            : 
    3456                 :            : /* Also a vector of input files specified.  */
    3457                 :            : 
    3458                 :            : static struct infile *infiles;
    3459                 :            : 
    3460                 :            : int n_infiles;
    3461                 :            : 
    3462                 :            : static int n_infiles_alloc;
    3463                 :            : 
    3464                 :            : /* True if undefined environment variables encountered during spec processing
    3465                 :            :    are ok to ignore, typically when we're running for --help or --version.  */
    3466                 :            : 
    3467                 :            : static bool spec_undefvar_allowed;
    3468                 :            : 
    3469                 :            : /* True if multiple input files are being compiled to a single
    3470                 :            :    assembly file.  */
    3471                 :            : 
    3472                 :            : static bool combine_inputs;
    3473                 :            : 
    3474                 :            : /* This counts the number of libraries added by lang_specific_driver, so that
    3475                 :            :    we can tell if there were any user supplied any files or libraries.  */
    3476                 :            : 
    3477                 :            : static int added_libraries;
    3478                 :            : 
    3479                 :            : /* And a vector of corresponding output files is made up later.  */
    3480                 :            : 
    3481                 :            : const char **outfiles;
    3482                 :            : 
    3483                 :            : #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
    3484                 :            : 
    3485                 :            : /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
    3486                 :            :    is true if we should look for an executable suffix.  DO_OBJ
    3487                 :            :    is true if we should look for an object suffix.  */
    3488                 :            : 
    3489                 :            : static const char *
    3490                 :            : convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
    3491                 :            :                   int do_obj ATTRIBUTE_UNUSED)
    3492                 :            : {
    3493                 :            : #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
    3494                 :            :   int i;
    3495                 :            : #endif
    3496                 :            :   int len;
    3497                 :            : 
    3498                 :            :   if (name == NULL)
    3499                 :            :     return NULL;
    3500                 :            : 
    3501                 :            :   len = strlen (name);
    3502                 :            : 
    3503                 :            : #ifdef HAVE_TARGET_OBJECT_SUFFIX
    3504                 :            :   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
    3505                 :            :   if (do_obj && len > 2
    3506                 :            :       && name[len - 2] == '.'
    3507                 :            :       && name[len - 1] == 'o')
    3508                 :            :     {
    3509                 :            :       obstack_grow (&obstack, name, len - 2);
    3510                 :            :       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
    3511                 :            :       name = XOBFINISH (&obstack, const char *);
    3512                 :            :     }
    3513                 :            : #endif
    3514                 :            : 
    3515                 :            : #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
    3516                 :            :   /* If there is no filetype, make it the executable suffix (which includes
    3517                 :            :      the ".").  But don't get confused if we have just "-o".  */
    3518                 :            :   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
    3519                 :            :     return name;
    3520                 :            : 
    3521                 :            :   for (i = len - 1; i >= 0; i--)
    3522                 :            :     if (IS_DIR_SEPARATOR (name[i]))
    3523                 :            :       break;
    3524                 :            : 
    3525                 :            :   for (i++; i < len; i++)
    3526                 :            :     if (name[i] == '.')
    3527                 :            :       return name;
    3528                 :            : 
    3529                 :            :   obstack_grow (&obstack, name, len);
    3530                 :            :   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
    3531                 :            :                  strlen (TARGET_EXECUTABLE_SUFFIX));
    3532                 :            :   name = XOBFINISH (&obstack, const char *);
    3533                 :            : #endif
    3534                 :            : 
    3535                 :            :   return name;
    3536                 :            : }
    3537                 :            : #endif
    3538                 :            : 
    3539                 :            : /* Display the command line switches accepted by gcc.  */
    3540                 :            : static void
    3541                 :          4 : display_help (void)
    3542                 :            : {
    3543                 :          4 :   printf (_("Usage: %s [options] file...\n"), progname);
    3544                 :          4 :   fputs (_("Options:\n"), stdout);
    3545                 :            : 
    3546                 :          4 :   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase.\n"), stdout);
    3547                 :          4 :   fputs (_("  --help                   Display this information.\n"), stdout);
    3548                 :          4 :   fputs (_("  --target-help            Display target specific command line options.\n"), stdout);
    3549                 :          4 :   fputs (_("  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout);
    3550                 :          4 :   fputs (_("                           Display specific types of command line options.\n"), stdout);
    3551                 :          4 :   if (! verbose_flag)
    3552                 :          1 :     fputs (_("  (Use '-v --help' to display command line options of sub-processes).\n"), stdout);
    3553                 :          4 :   fputs (_("  --version                Display compiler version information.\n"), stdout);
    3554                 :          4 :   fputs (_("  -dumpspecs               Display all of the built in spec strings.\n"), stdout);
    3555                 :          4 :   fputs (_("  -dumpversion             Display the version of the compiler.\n"), stdout);
    3556                 :          4 :   fputs (_("  -dumpmachine             Display the compiler's target processor.\n"), stdout);
    3557                 :          4 :   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path.\n"), stdout);
    3558                 :          4 :   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library.\n"), stdout);
    3559                 :          4 :   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>.\n"), stdout);
    3560                 :          4 :   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>.\n"), stdout);
    3561                 :          4 :   fputs (_("\
    3562                 :            :   -print-multiarch         Display the target's normalized GNU triplet, used as\n\
    3563                 :            :                            a component in the library path.\n"), stdout);
    3564                 :          4 :   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc.\n"), stdout);
    3565                 :          4 :   fputs (_("\
    3566                 :            :   -print-multi-lib         Display the mapping between command line options and\n\
    3567                 :            :                            multiple library search directories.\n"), stdout);
    3568                 :          4 :   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout);
    3569                 :          4 :   fputs (_("  -print-sysroot           Display the target libraries directory.\n"), stdout);
    3570                 :          4 :   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout);
    3571                 :          4 :   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler.\n"), stdout);
    3572                 :          4 :   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor.\n"), stdout);
    3573                 :          4 :   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker.\n"), stdout);
    3574                 :          4 :   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler.\n"), stdout);
    3575                 :          4 :   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor.\n"), stdout);
    3576                 :          4 :   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker.\n"), stdout);
    3577                 :          4 :   fputs (_("  -save-temps              Do not delete intermediate files.\n"), stdout);
    3578                 :          4 :   fputs (_("  -save-temps=<arg>        Do not delete intermediate files.\n"), stdout);
    3579                 :          4 :   fputs (_("\
    3580                 :            :   -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
    3581                 :            :                            prefixes to other gcc components.\n"), stdout);
    3582                 :          4 :   fputs (_("  -pipe                    Use pipes rather than intermediate files.\n"), stdout);
    3583                 :          4 :   fputs (_("  -time                    Time the execution of each subprocess.\n"), stdout);
    3584                 :          4 :   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>.\n"), stdout);
    3585                 :          4 :   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>.\n"), stdout);
    3586                 :          4 :   fputs (_("\
    3587                 :            :   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
    3588                 :            :                            and libraries.\n"), stdout);
    3589                 :          4 :   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths.\n"), stdout);
    3590                 :          4 :   fputs (_("  -v                       Display the programs invoked by the compiler.\n"), stdout);
    3591                 :          4 :   fputs (_("  -###                     Like -v but options quoted and commands not executed.\n"), stdout);
    3592                 :          4 :   fputs (_("  -E                       Preprocess only; do not compile, assemble or link.\n"), stdout);
    3593                 :          4 :   fputs (_("  -S                       Compile only; do not assemble or link.\n"), stdout);
    3594                 :          4 :   fputs (_("  -c                       Compile and assemble, but do not link.\n"), stdout);
    3595                 :          4 :   fputs (_("  -o <file>                Place the output into <file>.\n"), stdout);
    3596                 :          4 :   fputs (_("  -pie                     Create a dynamically linked position independent\n\
    3597                 :            :                            executable.\n"), stdout);
    3598                 :          4 :   fputs (_("  -shared                  Create a shared library.\n"), stdout);
    3599                 :          4 :   fputs (_("\
    3600                 :            :   -x <language>            Specify the language of the following input files.\n\
    3601                 :            :                            Permissible languages include: c c++ assembler none\n\
    3602                 :            :                            'none' means revert to the default behavior of\n\
    3603                 :            :                            guessing the language based on the file's extension.\n\
    3604                 :            : "), stdout);
    3605                 :            : 
    3606                 :          4 :   printf (_("\
    3607                 :            : \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
    3608                 :            :  passed on to the various sub-processes invoked by %s.  In order to pass\n\
    3609                 :            :  other options on to these processes the -W<letter> options must be used.\n\
    3610                 :            : "), progname);
    3611                 :            : 
    3612                 :            :   /* The rest of the options are displayed by invocations of the various
    3613                 :            :      sub-processes.  */
    3614                 :          4 : }
    3615                 :            : 
    3616                 :            : static void
    3617                 :          0 : add_preprocessor_option (const char *option, int len)
    3618                 :            : {
    3619                 :          0 :   preprocessor_options.safe_push (save_string (option, len));
    3620                 :          0 : }
    3621                 :            : 
    3622                 :            : static void
    3623                 :        166 : add_assembler_option (const char *option, int len)
    3624                 :            : {
    3625                 :        166 :   assembler_options.safe_push (save_string (option, len));
    3626                 :        166 : }
    3627                 :            : 
    3628                 :            : static void
    3629                 :         68 : add_linker_option (const char *option, int len)
    3630                 :            : {
    3631                 :         68 :   linker_options.safe_push (save_string (option, len));
    3632                 :         68 : }
    3633                 :            : 
    3634                 :            : /* Allocate space for an input file in infiles.  */
    3635                 :            : 
    3636                 :            : static void
    3637                 :     579747 : alloc_infile (void)
    3638                 :            : {
    3639                 :     579747 :   if (n_infiles_alloc == 0)
    3640                 :            :     {
    3641                 :     202778 :       n_infiles_alloc = 16;
    3642                 :     202778 :       infiles = XNEWVEC (struct infile, n_infiles_alloc);
    3643                 :            :     }
    3644                 :     376969 :   else if (n_infiles_alloc == n_infiles)
    3645                 :            :     {
    3646                 :        205 :       n_infiles_alloc *= 2;
    3647                 :        205 :       infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
    3648                 :            :     }
    3649                 :     579747 : }
    3650                 :            : 
    3651                 :            : /* Store an input file with the given NAME and LANGUAGE in
    3652                 :            :    infiles.  */
    3653                 :            : 
    3654                 :            : static void
    3655                 :     377011 : add_infile (const char *name, const char *language)
    3656                 :            : {
    3657                 :          0 :   alloc_infile ();
    3658                 :     377011 :   infiles[n_infiles].name = name;
    3659                 :     377011 :   infiles[n_infiles++].language = language;
    3660                 :     219759 : }
    3661                 :            : 
    3662                 :            : /* Allocate space for a switch in switches.  */
    3663                 :            : 
    3664                 :            : static void
    3665                 :    4338690 : alloc_switch (void)
    3666                 :            : {
    3667                 :    4338690 :   if (n_switches_alloc == 0)
    3668                 :            :     {
    3669                 :     203009 :       n_switches_alloc = 16;
    3670                 :     203009 :       switches = XNEWVEC (struct switchstr, n_switches_alloc);
    3671                 :            :     }
    3672                 :    4135680 :   else if (n_switches_alloc == n_switches)
    3673                 :            :     {
    3674                 :     141250 :       n_switches_alloc *= 2;
    3675                 :     141250 :       switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
    3676                 :            :     }
    3677                 :    4338690 : }
    3678                 :            : 
    3679                 :            : /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
    3680                 :            :    as validated if VALIDATED and KNOWN if it is an internal switch.  */
    3681                 :            : 
    3682                 :            : static void
    3683                 :    3750940 : save_switch (const char *opt, size_t n_args, const char *const *args,
    3684                 :            :              bool validated, bool known)
    3685                 :            : {
    3686                 :    3750940 :   alloc_switch ();
    3687                 :    3750940 :   switches[n_switches].part1 = opt + 1;
    3688                 :    3750940 :   if (n_args == 0)
    3689                 :    2570090 :     switches[n_switches].args = 0;
    3690                 :            :   else
    3691                 :            :     {
    3692                 :    1180860 :       switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
    3693                 :    1180860 :       memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
    3694                 :    1180860 :       switches[n_switches].args[n_args] = NULL;
    3695                 :            :     }
    3696                 :            : 
    3697                 :    3750940 :   switches[n_switches].live_cond = 0;
    3698                 :    3750940 :   switches[n_switches].validated = validated;
    3699                 :    3750940 :   switches[n_switches].known = known;
    3700                 :    3750940 :   switches[n_switches].ordering = 0;
    3701                 :    3750940 :   n_switches++;
    3702                 :    3750940 : }
    3703                 :            : 
    3704                 :            : /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
    3705                 :            :    not set already.  */
    3706                 :            : 
    3707                 :            : static void
    3708                 :        797 : set_source_date_epoch_envvar ()
    3709                 :            : {
    3710                 :            :   /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
    3711                 :            :      of 64 bit integers.  */
    3712                 :        797 :   char source_date_epoch[21];
    3713                 :        797 :   time_t tt;
    3714                 :            : 
    3715                 :        797 :   errno = 0;
    3716                 :        797 :   tt = time (NULL);
    3717                 :        797 :   if (tt < (time_t) 0 || errno != 0)
    3718                 :          0 :     tt = (time_t) 0;
    3719                 :            : 
    3720                 :        797 :   snprintf (source_date_epoch, 21, "%llu", (unsigned long long) tt);
    3721                 :            :   /* Using setenv instead of xputenv because we want the variable to remain
    3722                 :            :      after finalizing so that it's still set in the second run when using
    3723                 :            :      -fcompare-debug.  */
    3724                 :        797 :   setenv ("SOURCE_DATE_EPOCH", source_date_epoch, 0);
    3725                 :        797 : }
    3726                 :            : 
    3727                 :            : /* Handle an option DECODED that is unknown to the option-processing
    3728                 :            :    machinery.  */
    3729                 :            : 
    3730                 :            : static bool
    3731                 :        347 : driver_unknown_option_callback (const struct cl_decoded_option *decoded)
    3732                 :            : {
    3733                 :        347 :   const char *opt = decoded->arg;
    3734                 :        347 :   if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
    3735                 :          5 :       && !(decoded->errors & CL_ERR_NEGATIVE))
    3736                 :            :     {
    3737                 :            :       /* Leave unknown -Wno-* options for the compiler proper, to be
    3738                 :            :          diagnosed only if there are warnings.  */
    3739                 :          3 :       save_switch (decoded->canonical_option[0],
    3740                 :          3 :                    decoded->canonical_option_num_elements - 1,
    3741                 :            :                    &decoded->canonical_option[1], false, true);
    3742                 :          3 :       return false;
    3743                 :            :     }
    3744                 :        344 :   if (decoded->opt_index == OPT_SPECIAL_unknown)
    3745                 :            :     {
    3746                 :            :       /* Give it a chance to define it a spec file.  */
    3747                 :        344 :       save_switch (decoded->canonical_option[0],
    3748                 :        344 :                    decoded->canonical_option_num_elements - 1,
    3749                 :            :                    &decoded->canonical_option[1], false, false);
    3750                 :        344 :       return false;
    3751                 :            :     }
    3752                 :            :   else
    3753                 :            :     return true;
    3754                 :            : }
    3755                 :            : 
    3756                 :            : /* Handle an option DECODED that is not marked as CL_DRIVER.
    3757                 :            :    LANG_MASK will always be CL_DRIVER.  */
    3758                 :            : 
    3759                 :            : static void
    3760                 :    2282290 : driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
    3761                 :            :                             unsigned int lang_mask ATTRIBUTE_UNUSED)
    3762                 :            : {
    3763                 :            :   /* At this point, non-driver options are accepted (and expected to
    3764                 :            :      be passed down by specs) unless marked to be rejected by the
    3765                 :            :      driver.  Options to be rejected by the driver but accepted by the
    3766                 :            :      compilers proper are treated just like completely unknown
    3767                 :            :      options.  */
    3768                 :    2282290 :   const struct cl_option *option = &cl_options[decoded->opt_index];
    3769                 :            : 
    3770                 :    2282290 :   if (option->cl_reject_driver)
    3771                 :          0 :     error ("unrecognized command-line option %qs",
    3772                 :          0 :            decoded->orig_option_with_args_text);
    3773                 :            :   else
    3774                 :    2282290 :     save_switch (decoded->canonical_option[0],
    3775                 :    2282290 :                  decoded->canonical_option_num_elements - 1,
    3776                 :            :                  &decoded->canonical_option[1], false, true);
    3777                 :    2282290 : }
    3778                 :            : 
    3779                 :            : static const char *spec_lang = 0;
    3780                 :            : static int last_language_n_infiles;
    3781                 :            : 
    3782                 :            : /* Parse -foffload option argument.  */
    3783                 :            : 
    3784                 :            : static void
    3785                 :       4260 : handle_foffload_option (const char *arg)
    3786                 :            : {
    3787                 :       4260 :   const char *c, *cur, *n, *next, *end;
    3788                 :       4260 :   char *target;
    3789                 :            : 
    3790                 :            :   /* If option argument starts with '-' then no target is specified and we
    3791                 :            :      do not need to parse it.  */
    3792                 :       4260 :   if (arg[0] == '-')
    3793                 :            :     return;
    3794                 :            : 
    3795                 :       1712 :   end = strchr (arg, '=');
    3796                 :       1712 :   if (end == NULL)
    3797                 :       1712 :     end = strchr (arg, '\0');
    3798                 :       1712 :   cur = arg;
    3799                 :            : 
    3800                 :       1712 :   while (cur < end)
    3801                 :            :     {
    3802                 :       1712 :       next = strchr (cur, ',');
    3803                 :       1712 :       if (next == NULL)
    3804                 :       1712 :         next = end;
    3805                 :       1712 :       next = (next > end) ? end : next;
    3806                 :            : 
    3807                 :       1712 :       target = XNEWVEC (char, next - cur + 1);
    3808                 :       1712 :       memcpy (target, cur, next - cur);
    3809                 :       1712 :       target[next - cur] = '\0';
    3810                 :            : 
    3811                 :            :       /* If 'disable' is passed to the option, stop parsing the option and clean
    3812                 :            :          the list of offload targets.  */
    3813                 :       1712 :       if (strcmp (target, "disable") == 0)
    3814                 :            :         {
    3815                 :       1671 :           free (offload_targets);
    3816                 :       1671 :           offload_targets = xstrdup ("");
    3817                 :       1671 :           break;
    3818                 :            :         }
    3819                 :            : 
    3820                 :            :       /* Check that GCC is configured to support the offload target.  */
    3821                 :            :       c = OFFLOAD_TARGETS;
    3822                 :         82 :       while (c)
    3823                 :            :         {
    3824                 :         41 :           n = strchr (c, ',');
    3825                 :         41 :           if (n == NULL)
    3826                 :         41 :             n = strchr (c, '\0');
    3827                 :            : 
    3828                 :         41 :           if (next - cur == n - c && strncmp (target, c, n - c) == 0)
    3829                 :            :             break;
    3830                 :            : 
    3831                 :         41 :           c = *n ? n + 1 : NULL;
    3832                 :            :         }
    3833                 :            : 
    3834                 :         41 :       if (!c)
    3835                 :         41 :         fatal_error (input_location,
    3836                 :            :                      "GCC is not configured to support %s as offload target",
    3837                 :            :                      target);
    3838                 :            : 
    3839                 :          0 :       if (!offload_targets)
    3840                 :            :         {
    3841                 :          0 :           offload_targets = target;
    3842                 :          0 :           target = NULL;
    3843                 :            :         }
    3844                 :            :       else
    3845                 :            :         {
    3846                 :            :           /* Check that the target hasn't already presented in the list.  */
    3847                 :            :           c = offload_targets;
    3848                 :          0 :           do
    3849                 :            :             {
    3850                 :          0 :               n = strchr (c, ':');
    3851                 :          0 :               if (n == NULL)
    3852                 :          0 :                 n = strchr (c, '\0');
    3853                 :            : 
    3854                 :          0 :               if (next - cur == n - c && strncmp (c, target, n - c) == 0)
    3855                 :            :                 break;
    3856                 :            : 
    3857                 :          0 :               c = n + 1;
    3858                 :            :             }
    3859                 :          0 :           while (*n);
    3860                 :            : 
    3861                 :            :           /* If duplicate is not found, append the target to the list.  */
    3862                 :          0 :           if (c > n)
    3863                 :            :             {
    3864                 :          0 :               size_t offload_targets_len = strlen (offload_targets);
    3865                 :          0 :               offload_targets
    3866                 :          0 :                 = XRESIZEVEC (char, offload_targets,
    3867                 :            :                               offload_targets_len + 1 + next - cur + 1);
    3868                 :          0 :               offload_targets[offload_targets_len++] = ':';
    3869                 :          0 :               memcpy (offload_targets + offload_targets_len, target, next - cur + 1);
    3870                 :            :             }
    3871                 :            :         }
    3872                 :            : 
    3873                 :          0 :       cur = next + 1;
    3874                 :          0 :       XDELETEVEC (target);
    3875                 :            :     }
    3876                 :            : }
    3877                 :            : 
    3878                 :            : /* Handle a driver option; arguments and return value as for
    3879                 :            :    handle_option.  */
    3880                 :            : 
    3881                 :            : static bool
    3882                 :    1658140 : driver_handle_option (struct gcc_options *opts,
    3883                 :            :                       struct gcc_options *opts_set,
    3884                 :            :                       const struct cl_decoded_option *decoded,
    3885                 :            :                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
    3886                 :            :                       location_t loc,
    3887                 :            :                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
    3888                 :            :                       diagnostic_context *dc,
    3889                 :            :                       void (*) (void))
    3890                 :            : {
    3891                 :    1658140 :   size_t opt_index = decoded->opt_index;
    3892                 :    1658140 :   const char *arg = decoded->arg;
    3893                 :    1658140 :   const char *compare_debug_replacement_opt;
    3894                 :    1658140 :   int value = decoded->value;
    3895                 :    1658140 :   bool validated = false;
    3896                 :    1658140 :   bool do_save = true;
    3897                 :            : 
    3898                 :    1658140 :   gcc_assert (opts == &global_options);
    3899                 :    1658140 :   gcc_assert (opts_set == &global_options_set);
    3900                 :    1658140 :   gcc_assert (kind == DK_UNSPECIFIED);
    3901                 :    1658140 :   gcc_assert (loc == UNKNOWN_LOCATION);
    3902                 :    1658140 :   gcc_assert (dc == global_dc);
    3903                 :            : 
    3904                 :    1658140 :   switch (opt_index)
    3905                 :            :     {
    3906                 :          1 :     case OPT_dumpspecs:
    3907                 :          1 :       {
    3908                 :          1 :         struct spec_list *sl;
    3909                 :          1 :         init_spec ();
    3910                 :         46 :         for (sl = specs; sl; sl = sl->next)
    3911                 :         45 :           printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
    3912                 :          1 :         if (link_command_spec)
    3913                 :          1 :           printf ("*link_command:\n%s\n\n", link_command_spec);
    3914                 :          1 :         exit (0);
    3915                 :            :       }
    3916                 :            : 
    3917                 :        223 :     case OPT_dumpversion:
    3918                 :        223 :       printf ("%s\n", spec_version);
    3919                 :        223 :       exit (0);
    3920                 :            : 
    3921                 :          0 :     case OPT_dumpmachine:
    3922                 :          0 :       printf ("%s\n", spec_machine);
    3923                 :          0 :       exit (0);
    3924                 :            : 
    3925                 :          0 :     case OPT_dumpfullversion:
    3926                 :          0 :       printf ("%s\n", BASEVER);
    3927                 :          0 :       exit (0);
    3928                 :            : 
    3929                 :         64 :     case OPT__version:
    3930                 :         64 :       print_version = 1;
    3931                 :            : 
    3932                 :            :       /* CPP driver cannot obtain switch from cc1_options.  */
    3933                 :         64 :       if (is_cpp_driver)
    3934                 :          0 :         add_preprocessor_option ("--version", strlen ("--version"));
    3935                 :         64 :       add_assembler_option ("--version", strlen ("--version"));
    3936                 :         64 :       add_linker_option ("--version", strlen ("--version"));
    3937                 :         64 :       break;
    3938                 :            : 
    3939                 :          5 :     case OPT__completion_:
    3940                 :          5 :       validated = true;
    3941                 :          5 :       completion = decoded->arg;
    3942                 :          5 :       break;
    3943                 :            : 
    3944                 :          4 :     case OPT__help:
    3945                 :          4 :       print_help_list = 1;
    3946                 :            : 
    3947                 :            :       /* CPP driver cannot obtain switch from cc1_options.  */
    3948                 :          4 :       if (is_cpp_driver)
    3949                 :          0 :         add_preprocessor_option ("--help", 6);
    3950                 :          4 :       add_assembler_option ("--help", 6);
    3951                 :          4 :       add_linker_option ("--help", 6);
    3952                 :          4 :       break;
    3953                 :            : 
    3954                 :         57 :     case OPT__help_:
    3955                 :         57 :       print_subprocess_help = 2;
    3956                 :         57 :       break;
    3957                 :            : 
    3958                 :          0 :     case OPT__target_help:
    3959                 :          0 :       print_subprocess_help = 1;
    3960                 :            : 
    3961                 :            :       /* CPP driver cannot obtain switch from cc1_options.  */
    3962                 :          0 :       if (is_cpp_driver)
    3963                 :          0 :         add_preprocessor_option ("--target-help", 13);
    3964                 :          0 :       add_assembler_option ("--target-help", 13);
    3965                 :          0 :       add_linker_option ("--target-help", 13);
    3966                 :          0 :       break;
    3967                 :            : 
    3968                 :            :     case OPT__no_sysroot_suffix:
    3969                 :            :     case OPT_pass_exit_codes:
    3970                 :            :     case OPT_print_search_dirs:
    3971                 :            :     case OPT_print_file_name_:
    3972                 :            :     case OPT_print_prog_name_:
    3973                 :            :     case OPT_print_multi_lib:
    3974                 :            :     case OPT_print_multi_directory:
    3975                 :            :     case OPT_print_sysroot:
    3976                 :            :     case OPT_print_multi_os_directory:
    3977                 :            :     case OPT_print_multiarch:
    3978                 :            :     case OPT_print_sysroot_headers_suffix:
    3979                 :            :     case OPT_time:
    3980                 :            :     case OPT_wrapper:
    3981                 :            :       /* These options set the variables specified in common.opt
    3982                 :            :          automatically, and do not need to be saved for spec
    3983                 :            :          processing.  */
    3984                 :            :       do_save = false;
    3985                 :            :       break;
    3986                 :            : 
    3987                 :        346 :     case OPT_print_libgcc_file_name:
    3988                 :        346 :       print_file_name = "libgcc.a";
    3989                 :        346 :       do_save = false;
    3990                 :        346 :       break;
    3991                 :            : 
    3992                 :          0 :     case OPT_fuse_ld_bfd:
    3993                 :          0 :        use_ld = ".bfd";
    3994                 :          0 :        break;
    3995                 :            : 
    3996                 :          0 :     case OPT_fuse_ld_gold:
    3997                 :          0 :        use_ld = ".gold";
    3998                 :          0 :        break;
    3999                 :            : 
    4000                 :          0 :     case OPT_fcompare_debug_second:
    4001                 :          0 :       compare_debug_second = 1;
    4002                 :          0 :       break;
    4003                 :            : 
    4004                 :        789 :     case OPT_fcompare_debug:
    4005                 :        789 :       switch (value)
    4006                 :            :         {
    4007                 :          0 :         case 0:
    4008                 :          0 :           compare_debug_replacement_opt = "-fcompare-debug=";
    4009                 :          0 :           arg = "";
    4010                 :          0 :           goto compare_debug_with_arg;
    4011                 :            : 
    4012                 :        789 :         case 1:
    4013                 :        789 :           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
    4014                 :        789 :           arg = "-gtoggle";
    4015                 :        789 :           goto compare_debug_with_arg;
    4016                 :            : 
    4017                 :          0 :         default:
    4018                 :          0 :           gcc_unreachable ();
    4019                 :            :         }
    4020                 :          8 :       break;
    4021                 :            : 
    4022                 :          8 :     case OPT_fcompare_debug_:
    4023                 :          8 :       compare_debug_replacement_opt = decoded->canonical_option[0];
    4024                 :        797 :     compare_debug_with_arg:
    4025                 :        797 :       gcc_assert (decoded->canonical_option_num_elements == 1);
    4026                 :        797 :       gcc_assert (arg != NULL);
    4027                 :        797 :       if (*arg)
    4028                 :        797 :         compare_debug = 1;
    4029                 :            :       else
    4030                 :          0 :         compare_debug = -1;
    4031                 :        797 :       if (compare_debug < 0)
    4032                 :          0 :         compare_debug_opt = NULL;
    4033                 :            :       else
    4034                 :        797 :         compare_debug_opt = arg;
    4035                 :        797 :       save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
    4036                 :        797 :       set_source_date_epoch_envvar ();
    4037                 :        797 :       return true;
    4038                 :            : 
    4039                 :     184516 :     case OPT_fdiagnostics_color_:
    4040                 :     184516 :       diagnostic_color_init (dc, value);
    4041                 :     184516 :       break;
    4042                 :            : 
    4043                 :     180390 :     case OPT_fdiagnostics_urls_:
    4044                 :     180390 :       diagnostic_urls_init (dc, value);
    4045                 :     180390 :       break;
    4046                 :            : 
    4047                 :          0 :     case OPT_fdiagnostics_format_:
    4048                 :          0 :       diagnostic_output_format_init (dc,
    4049                 :            :                                      (enum diagnostics_output_format)value);
    4050                 :          0 :       break;
    4051                 :            : 
    4052                 :            :     case OPT_Wa_:
    4053                 :            :       {
    4054                 :            :         int prev, j;
    4055                 :            :         /* Pass the rest of this option to the assembler.  */
    4056                 :            : 
    4057                 :            :         /* Split the argument at commas.  */
    4058                 :            :         prev = 0;
    4059                 :        409 :         for (j = 0; arg[j]; j++)
    4060                 :        376 :           if (arg[j] == ',')
    4061                 :            :             {
    4062                 :          0 :               add_assembler_option (arg + prev, j - prev);
    4063                 :          0 :               prev = j + 1;
    4064                 :            :             }
    4065                 :            : 
    4066                 :            :         /* Record the part after the last comma.  */
    4067                 :         33 :         add_assembler_option (arg + prev, j - prev);
    4068                 :            :       }
    4069                 :         33 :       do_save = false;
    4070                 :         33 :       break;
    4071                 :            : 
    4072                 :            :     case OPT_Wp_:
    4073                 :            :       {
    4074                 :            :         int prev, j;
    4075                 :            :         /* Pass the rest of this option to the preprocessor.  */
    4076                 :            : 
    4077                 :            :         /* Split the argument at commas.  */
    4078                 :            :         prev = 0;
    4079                 :          0 :         for (j = 0; arg[j]; j++)
    4080                 :          0 :           if (arg[j] == ',')
    4081                 :            :             {
    4082                 :          0 :               add_preprocessor_option (arg + prev, j - prev);
    4083                 :          0 :               prev = j + 1;
    4084                 :            :             }
    4085                 :            : 
    4086                 :            :         /* Record the part after the last comma.  */
    4087                 :          0 :         add_preprocessor_option (arg + prev, j - prev);
    4088                 :            :       }
    4089                 :          0 :       do_save = false;
    4090                 :          0 :       break;
    4091                 :            : 
    4092                 :            :     case OPT_Wl_:
    4093                 :            :       {
    4094                 :            :         int prev, j;
    4095                 :            :         /* Split the argument at commas.  */
    4096                 :            :         prev = 0;
    4097                 :      97762 :         for (j = 0; arg[j]; j++)
    4098                 :      91703 :           if (arg[j] == ',')
    4099                 :            :             {
    4100                 :          8 :               add_infile (save_string (arg + prev, j - prev), "*");
    4101                 :          8 :               prev = j + 1;
    4102                 :            :             }
    4103                 :            :         /* Record the part after the last comma.  */
    4104                 :       6059 :         add_infile (arg + prev, "*");
    4105                 :            :       }
    4106                 :       6059 :       do_save = false;
    4107                 :       6059 :       break;
    4108                 :            : 
    4109                 :          0 :     case OPT_Xlinker:
    4110                 :          0 :       add_infile (arg, "*");
    4111                 :          0 :       do_save = false;
    4112                 :          0 :       break;
    4113                 :            : 
    4114                 :          0 :     case OPT_Xpreprocessor:
    4115                 :          0 :       add_preprocessor_option (arg, strlen (arg));
    4116                 :          0 :       do_save = false;
    4117                 :          0 :       break;
    4118                 :            : 
    4119                 :         65 :     case OPT_Xassembler:
    4120                 :         65 :       add_assembler_option (arg, strlen (arg));
    4121                 :         65 :       do_save = false;
    4122                 :         65 :       break;
    4123                 :            : 
    4124                 :     151185 :     case OPT_l:
    4125                 :            :       /* POSIX allows separation of -l and the lib arg; canonicalize
    4126                 :            :          by concatenating -l with its arg */
    4127                 :     151185 :       add_infile (concat ("-l", arg, NULL), "*");
    4128                 :     151185 :       do_save = false;
    4129                 :     151185 :       break;
    4130                 :            : 
    4131                 :     196576 :     case OPT_L:
    4132                 :            :       /* Similarly, canonicalize -L for linkers that may not accept
    4133                 :            :          separate arguments.  */
    4134                 :     196576 :       save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
    4135                 :     196576 :       return true;
    4136                 :            : 
    4137                 :          0 :     case OPT_F:
    4138                 :            :       /* Likewise -F.  */
    4139                 :          0 :       save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
    4140                 :          0 :       return true;
    4141                 :            : 
    4142                 :        119 :     case OPT_save_temps:
    4143                 :        119 :       save_temps_flag = SAVE_TEMPS_CWD;
    4144                 :        119 :       validated = true;
    4145                 :        119 :       break;
    4146                 :            : 
    4147                 :          0 :     case OPT_save_temps_:
    4148                 :          0 :       if (strcmp (arg, "cwd") == 0)
    4149                 :          0 :         save_temps_flag = SAVE_TEMPS_CWD;
    4150                 :          0 :       else if (strcmp (arg, "obj") == 0
    4151                 :          0 :                || strcmp (arg, "object") == 0)
    4152                 :          0 :         save_temps_flag = SAVE_TEMPS_OBJ;
    4153                 :            :       else
    4154                 :          0 :         fatal_error (input_location, "%qs is an unknown %<-save-temps%> option",
    4155                 :          0 :                      decoded->orig_option_with_args_text);
    4156                 :            :       break;
    4157                 :            : 
    4158                 :            :     case OPT_no_canonical_prefixes:
    4159                 :            :       /* Already handled as a special case, so ignored here.  */
    4160                 :            :       do_save = false;
    4161                 :            :       break;
    4162                 :            : 
    4163                 :            :     case OPT_pipe:
    4164                 :            :       validated = true;
    4165                 :            :       /* These options set the variables specified in common.opt
    4166                 :            :          automatically, but do need to be saved for spec
    4167                 :            :          processing.  */
    4168                 :            :       break;
    4169                 :            : 
    4170                 :          3 :     case OPT_specs_:
    4171                 :          3 :       {
    4172                 :          3 :         struct user_specs *user = XNEW (struct user_specs);
    4173                 :            : 
    4174                 :          3 :         user->next = (struct user_specs *) 0;
    4175                 :          3 :         user->filename = arg;
    4176                 :          3 :         if (user_specs_tail)
    4177                 :          0 :           user_specs_tail->next = user;
    4178                 :            :         else
    4179                 :          3 :           user_specs_head = user;
    4180                 :          3 :         user_specs_tail = user;
    4181                 :            :       }
    4182                 :          3 :       validated = true;
    4183                 :          3 :       break;
    4184                 :            : 
    4185                 :          0 :     case OPT__sysroot_:
    4186                 :          0 :       target_system_root = arg;
    4187                 :          0 :       target_system_root_changed = 1;
    4188                 :          0 :       do_save = false;
    4189                 :          0 :       break;
    4190                 :            : 
    4191                 :          0 :     case OPT_time_:
    4192                 :          0 :       if (report_times_to_file)
    4193                 :          0 :         fclose (report_times_to_file);
    4194                 :          0 :       report_times_to_file = fopen (arg, "a");
    4195                 :          0 :       do_save = false;
    4196                 :          0 :       break;
    4197                 :            : 
    4198                 :        460 :     case OPT____:
    4199                 :            :       /* "-###"
    4200                 :            :          This is similar to -v except that there is no execution
    4201                 :            :          of the commands and the echoed arguments are quoted.  It
    4202                 :            :          is intended for use in shell scripts to capture the
    4203                 :            :          driver-generated command line.  */
    4204                 :        460 :       verbose_only_flag++;
    4205                 :        460 :       verbose_flag = 1;
    4206                 :        460 :       do_save = false;
    4207                 :        460 :       break;
    4208                 :            : 
    4209                 :     384244 :     case OPT_B:
    4210                 :     384244 :       {
    4211                 :     384244 :         size_t len = strlen (arg);
    4212                 :            : 
    4213                 :            :         /* Catch the case where the user has forgotten to append a
    4214                 :            :            directory separator to the path.  Note, they may be using
    4215                 :            :            -B to add an executable name prefix, eg "i386-elf-", in
    4216                 :            :            order to distinguish between multiple installations of
    4217                 :            :            GCC in the same directory.  Hence we must check to see
    4218                 :            :            if appending a directory separator actually makes a
    4219                 :            :            valid directory name.  */
    4220                 :     384244 :         if (!IS_DIR_SEPARATOR (arg[len - 1])
    4221                 :     384244 :             && is_directory (arg, false))
    4222                 :            :           {
    4223                 :      80638 :             char *tmp = XNEWVEC (char, len + 2);
    4224                 :      80638 :             strcpy (tmp, arg);
    4225                 :      80638 :             tmp[len] = DIR_SEPARATOR;
    4226                 :      80638 :             tmp[++len] = 0;
    4227                 :      80638 :             arg = tmp;
    4228                 :            :           }
    4229                 :            : 
    4230                 :     384244 :         add_prefix (&exec_prefixes, arg, NULL,
    4231                 :            :                     PREFIX_PRIORITY_B_OPT, 0, 0);
    4232                 :     384244 :         add_prefix (&startfile_prefixes, arg, NULL,
    4233                 :            :                     PREFIX_PRIORITY_B_OPT, 0, 0);
    4234                 :     384244 :         add_prefix (&include_prefixes, arg, NULL,
    4235                 :            :                     PREFIX_PRIORITY_B_OPT, 0, 0);
    4236                 :            :       }
    4237                 :     384244 :       validated = true;
    4238                 :     384244 :       break;
    4239                 :            : 
    4240                 :       1238 :     case OPT_E:
    4241                 :       1238 :       have_E = true;
    4242                 :       1238 :       break;
    4243                 :            : 
    4244                 :      30976 :     case OPT_x:
    4245                 :      30976 :       spec_lang = arg;
    4246                 :      30976 :       if (!strcmp (spec_lang, "none"))
    4247                 :            :         /* Suppress the warning if -xnone comes after the last input
    4248                 :            :            file, because alternate command interfaces like g++ might
    4249                 :            :            find it useful to place -xnone after each input file.  */
    4250                 :       7592 :         spec_lang = 0;
    4251                 :            :       else
    4252                 :      23384 :         last_language_n_infiles = n_infiles;
    4253                 :            :       do_save = false;
    4254                 :            :       break;
    4255                 :            : 
    4256                 :     191881 :     case OPT_o:
    4257                 :     191881 :       have_o = 1;
    4258                 :            : #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
    4259                 :            :       arg = convert_filename (arg, ! have_c, 0);
    4260                 :            : #endif
    4261                 :     191881 :       output_file = arg;
    4262                 :            :       /* Save the output name in case -save-temps=obj was used.  */
    4263                 :     191881 :       save_temps_prefix = xstrdup (arg);
    4264                 :            :       /* On some systems, ld cannot handle "-o" without a space.  So
    4265                 :            :          split the option from its argument.  */
    4266                 :     191881 :       save_switch ("-o", 1, &arg, validated, true);
    4267                 :     191881 :       return true;
    4268                 :            : 
    4269                 :            : #ifdef ENABLE_DEFAULT_PIE
    4270                 :            :     case OPT_pie:
    4271                 :            :       /* -pie is turned on by default.  */
    4272                 :            : #endif
    4273                 :            : 
    4274                 :            :     case OPT_static_libgcc:
    4275                 :            :     case OPT_shared_libgcc:
    4276                 :            :     case OPT_static_libgfortran:
    4277                 :            :     case OPT_static_libstdc__:
    4278                 :            :       /* These are always valid, since gcc.c itself understands the
    4279                 :            :          first two, gfortranspec.c understands -static-libgfortran and
    4280                 :            :          g++spec.c understands -static-libstdc++ */
    4281                 :            :       validated = true;
    4282                 :            :       break;
    4283                 :            : 
    4284                 :       5015 :     case OPT_fwpa:
    4285                 :       5015 :       flag_wpa = "";
    4286                 :       5015 :       break;
    4287                 :            : 
    4288                 :       4260 :     case OPT_foffload_:
    4289                 :       4260 :       handle_foffload_option (arg);
    4290                 :       4260 :       break;
    4291                 :            : 
    4292                 :            :     default:
    4293                 :            :       /* Various driver options need no special processing at this
    4294                 :            :          point, having been handled in a prescan above or being
    4295                 :            :          handled by specs.  */
    4296                 :            :       break;
    4297                 :            :     }
    4298                 :            : 
    4299                 :     918063 :   if (do_save)
    4300                 :    1077460 :     save_switch (decoded->canonical_option[0],
    4301                 :    1077460 :                  decoded->canonical_option_num_elements - 1,
    4302                 :            :                  &decoded->canonical_option[1], validated, true);
    4303                 :            :   return true;
    4304                 :            : }
    4305                 :            : 
    4306                 :            : /* Put the driver's standard set of option handlers in *HANDLERS.  */
    4307                 :            : 
    4308                 :            : static void
    4309                 :     588014 : set_option_handlers (struct cl_option_handlers *handlers)
    4310                 :            : {
    4311                 :     588014 :   handlers->unknown_option_callback = driver_unknown_option_callback;
    4312                 :     588014 :   handlers->wrong_lang_callback = driver_wrong_lang_callback;
    4313                 :     588014 :   handlers->num_handlers = 3;
    4314                 :     588014 :   handlers->handlers[0].handler = driver_handle_option;
    4315                 :     588014 :   handlers->handlers[0].mask = CL_DRIVER;
    4316                 :     588014 :   handlers->handlers[1].handler = common_handle_option;
    4317                 :     588014 :   handlers->handlers[1].mask = CL_COMMON;
    4318                 :     588014 :   handlers->handlers[2].handler = target_handle_option;
    4319                 :     588014 :   handlers->handlers[2].mask = CL_TARGET;
    4320                 :          0 : }
    4321                 :            : 
    4322                 :            : /* Create the vector `switches' and its contents.
    4323                 :            :    Store its length in `n_switches'.  */
    4324                 :            : 
    4325                 :            : static void
    4326                 :     203006 : process_command (unsigned int decoded_options_count,
    4327                 :            :                  struct cl_decoded_option *decoded_options)
    4328                 :            : {
    4329                 :     203006 :   const char *temp;
    4330                 :     203006 :   char *temp1;
    4331                 :     203006 :   char *tooldir_prefix, *tooldir_prefix2;
    4332                 :     203006 :   char *(*get_relative_prefix) (const char *, const char *,
    4333                 :            :                                 const char *) = NULL;
    4334                 :     203006 :   struct cl_option_handlers handlers;
    4335                 :     203006 :   unsigned int j;
    4336                 :            : 
    4337                 :     203006 :   gcc_exec_prefix = env.get ("GCC_EXEC_PREFIX");
    4338                 :            : 
    4339                 :     203006 :   n_switches = 0;
    4340                 :     203006 :   n_infiles = 0;
    4341                 :     203006 :   added_libraries = 0;
    4342                 :            : 
    4343                 :            :   /* Figure compiler version from version string.  */
    4344                 :            : 
    4345                 :     203006 :   compiler_version = temp1 = xstrdup (version_string);
    4346                 :            : 
    4347                 :    1421040 :   for (; *temp1; ++temp1)
    4348                 :            :     {
    4349                 :    1421040 :       if (*temp1 == ' ')
    4350                 :            :         {
    4351                 :     203006 :           *temp1 = '\0';
    4352                 :     203006 :           break;
    4353                 :            :         }
    4354                 :            :     }
    4355                 :            : 
    4356                 :            :   /* Handle any -no-canonical-prefixes flag early, to assign the function
    4357                 :            :      that builds relative prefixes.  This function creates default search
    4358                 :            :      paths that are needed later in normal option handling.  */
    4359                 :            : 
    4360                 :    3785510 :   for (j = 1; j < decoded_options_count; j++)
    4361                 :            :     {
    4362                 :    3582500 :       if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
    4363                 :            :         {
    4364                 :            :           get_relative_prefix = make_relative_prefix_ignore_links;
    4365                 :            :           break;
    4366                 :            :         }
    4367                 :            :     }
    4368                 :     203006 :   if (! get_relative_prefix)
    4369                 :     203006 :     get_relative_prefix = make_relative_prefix;
    4370                 :            : 
    4371                 :            :   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
    4372                 :            :      see if we can create it from the pathname specified in
    4373                 :            :      decoded_options[0].arg.  */
    4374                 :            : 
    4375                 :     203006 :   gcc_libexec_prefix = standard_libexec_prefix;
    4376                 :            : #ifndef VMS
    4377                 :            :   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
    4378                 :     203006 :   if (!gcc_exec_prefix)
    4379                 :            :     {
    4380                 :      20273 :       gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
    4381                 :            :                                              standard_bindir_prefix,
    4382                 :            :                                              standard_exec_prefix);
    4383                 :      20273 :       gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
    4384                 :            :                                              standard_bindir_prefix,
    4385                 :            :                                              standard_libexec_prefix);
    4386                 :      20273 :       if (gcc_exec_prefix)
    4387                 :      20273 :         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
    4388                 :            :     }
    4389                 :            :   else
    4390                 :            :     {
    4391                 :            :       /* make_relative_prefix requires a program name, but
    4392                 :            :          GCC_EXEC_PREFIX is typically a directory name with a trailing
    4393                 :            :          / (which is ignored by make_relative_prefix), so append a
    4394                 :            :          program name.  */
    4395                 :     182733 :       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
    4396                 :     182733 :       gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
    4397                 :            :                                                 standard_exec_prefix,
    4398                 :            :                                                 standard_libexec_prefix);
    4399                 :            : 
    4400                 :            :       /* The path is unrelocated, so fallback to the original setting.  */
    4401                 :     182733 :       if (!gcc_libexec_prefix)
    4402                 :     182532 :         gcc_libexec_prefix = standard_libexec_prefix;
    4403                 :            : 
    4404                 :     182733 :       free (tmp_prefix);
    4405                 :            :     }
    4406                 :            : #else
    4407                 :            : #endif
    4408                 :            :   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
    4409                 :            :      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
    4410                 :            :      or an automatically created GCC_EXEC_PREFIX from
    4411                 :            :      decoded_options[0].arg.  */
    4412                 :            : 
    4413                 :            :   /* Do language-specific adjustment/addition of flags.  */
    4414                 :     203006 :   lang_specific_driver (&decoded_options, &decoded_options_count,
    4415                 :            :                         &added_libraries);
    4416                 :            : 
    4417                 :     203002 :   if (gcc_exec_prefix)
    4418                 :            :     {
    4419                 :     203002 :       int len = strlen (gcc_exec_prefix);
    4420                 :            : 
    4421                 :     203002 :       if (len > (int) sizeof ("/lib/gcc/") - 1
    4422                 :     203002 :           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
    4423                 :            :         {
    4424                 :     203002 :           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
    4425                 :     203002 :           if (IS_DIR_SEPARATOR (*temp)
    4426                 :          0 :               && filename_ncmp (temp + 1, "lib", 3) == 0
    4427                 :          0 :               && IS_DIR_SEPARATOR (temp[4])
    4428                 :     203002 :               && filename_ncmp (temp + 5, "gcc", 3) == 0)
    4429                 :          0 :             len -= sizeof ("/lib/gcc/") - 1;
    4430                 :            :         }
    4431                 :            : 
    4432                 :     203002 :       set_std_prefix (gcc_exec_prefix, len);
    4433                 :     203002 :       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
    4434                 :            :                   PREFIX_PRIORITY_LAST, 0, 0);
    4435                 :     203002 :       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
    4436                 :            :                   PREFIX_PRIORITY_LAST, 0, 0);
    4437                 :            :     }
    4438                 :            : 
    4439                 :            :   /* COMPILER_PATH and LIBRARY_PATH have values
    4440                 :            :      that are lists of directory names with colons.  */
    4441                 :            : 
    4442                 :     203002 :   temp = env.get ("COMPILER_PATH");
    4443                 :     203002 :   if (temp)
    4444                 :            :     {
    4445                 :      14009 :       const char *startp, *endp;
    4446                 :      14009 :       char *nstore = (char *) alloca (strlen (temp) + 3);
    4447                 :            : 
    4448                 :      14009 :       startp = endp = temp;
    4449                 :    2013640 :       while (1)
    4450                 :            :         {
    4451                 :    2013640 :           if (*endp == PATH_SEPARATOR || *endp == 0)
    4452                 :            :             {
    4453                 :      23209 :               strncpy (nstore, startp, endp - startp);
    4454                 :      23209 :               if (endp == startp)
    4455                 :          0 :                 strcpy (nstore, concat (".", dir_separator_str, NULL));
    4456                 :      23209 :               else if (!IS_DIR_SEPARATOR (endp[-1]))
    4457                 :            :                 {
    4458                 :          0 :                   nstore[endp - startp] = DIR_SEPARATOR;
    4459                 :          0 :                   nstore[endp - startp + 1] = 0;
    4460                 :            :                 }
    4461                 :            :               else
    4462                 :      23209 :                 nstore[endp - startp] = 0;
    4463                 :      23209 :               add_prefix (&exec_prefixes, nstore, 0,
    4464                 :            :                           PREFIX_PRIORITY_LAST, 0, 0);
    4465                 :      23209 :               add_prefix (&include_prefixes, nstore, 0,
    4466                 :            :                           PREFIX_PRIORITY_LAST, 0, 0);
    4467                 :      23209 :               if (*endp == 0)
    4468                 :            :                 break;
    4469                 :       9200 :               endp = startp = endp + 1;
    4470                 :            :             }
    4471                 :            :           else
    4472                 :    1990430 :             endp++;
    4473                 :            :         }
    4474                 :            :     }
    4475                 :            : 
    4476                 :     203002 :   temp = env.get (LIBRARY_PATH_ENV);
    4477                 :     203002 :   if (temp && *cross_compile == '0')
    4478                 :            :     {
    4479                 :      15044 :       const char *startp, *endp;
    4480                 :      15044 :       char *nstore = (char *) alloca (strlen (temp) + 3);
    4481                 :            : 
    4482                 :      15044 :       startp = endp = temp;
    4483                 :    3413000 :       while (1)
    4484                 :            :         {
    4485                 :    3413000 :           if (*endp == PATH_SEPARATOR || *endp == 0)
    4486                 :            :             {
    4487                 :     107896 :               strncpy (nstore, startp, endp - startp);
    4488                 :     107896 :               if (endp == startp)
    4489                 :          0 :                 strcpy (nstore, concat (".", dir_separator_str, NULL));
    4490                 :     107896 :               else if (!IS_DIR_SEPARATOR (endp[-1]))
    4491                 :            :                 {
    4492                 :       1035 :                   nstore[endp - startp] = DIR_SEPARATOR;
    4493                 :       1035 :                   nstore[endp - startp + 1] = 0;
    4494                 :            :                 }
    4495                 :            :               else
    4496                 :     106861 :                 nstore[endp - startp] = 0;
    4497                 :     107896 :               add_prefix (&startfile_prefixes, nstore, NULL,
    4498                 :            :                           PREFIX_PRIORITY_LAST, 0, 1);
    4499                 :     107896 :               if (*endp == 0)
    4500                 :            :                 break;
    4501                 :      92852 :               endp = startp = endp + 1;
    4502                 :            :             }
    4503                 :            :           else
    4504                 :    3305100 :             endp++;
    4505                 :            :         }
    4506                 :            :     }
    4507                 :            : 
    4508                 :            :   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
    4509                 :     203002 :   temp = env.get ("LPATH");
    4510                 :     203002 :   if (temp && *cross_compile == '0')
    4511                 :            :     {
    4512                 :          0 :       const char *startp, *endp;
    4513                 :          0 :       char *nstore = (char *) alloca (strlen (temp) + 3);
    4514                 :            : 
    4515                 :          0 :       startp = endp = temp;
    4516                 :          0 :       while (1)
    4517                 :            :         {
    4518                 :          0 :           if (*endp == PATH_SEPARATOR || *endp == 0)
    4519                 :            :             {
    4520                 :          0 :               strncpy (nstore, startp, endp - startp);
    4521                 :          0 :               if (endp == startp)
    4522                 :          0 :                 strcpy (nstore, concat (".", dir_separator_str, NULL));
    4523                 :          0 :               else if (!IS_DIR_SEPARATOR (endp[-1]))
    4524                 :            :                 {
    4525                 :          0 :                   nstore[endp - startp] = DIR_SEPARATOR;
    4526                 :          0 :                   nstore[endp - startp + 1] = 0;
    4527                 :            :                 }
    4528                 :            :               else
    4529                 :          0 :                 nstore[endp - startp] = 0;
    4530                 :          0 :               add_prefix (&startfile_prefixes, nstore, NULL,
    4531                 :            :                           PREFIX_PRIORITY_LAST, 0, 1);
    4532                 :          0 :               if (*endp == 0)
    4533                 :            :                 break;
    4534                 :          0 :               endp = startp = endp + 1;
    4535                 :            :             }
    4536                 :            :           else
    4537                 :          0 :             endp++;
    4538                 :            :         }
    4539                 :            :     }
    4540                 :            : 
    4541                 :            :   /* Process the options and store input files and switches in their
    4542                 :            :      vectors.  */
    4543                 :            : 
    4544                 :     203002 :   last_language_n_infiles = -1;
    4545                 :            : 
    4546                 :     203002 :   set_option_handlers (&handlers);
    4547                 :            : 
    4548                 :    3297800 :   for (j = 1; j < decoded_options_count; j++)
    4549                 :            :     {
    4550                 :    3221670 :       switch (decoded_options[j].opt_index)
    4551                 :            :         {
    4552                 :     126880 :         case OPT_S:
    4553                 :     126880 :         case OPT_c:
    4554                 :     126880 :         case OPT_E:
    4555                 :     126880 :           have_c = 1;
    4556                 :     126880 :           break;
    4557                 :            :         }
    4558                 :    3221670 :       if (have_c)
    4559                 :            :         break;
    4560                 :            :     }
    4561                 :            : 
    4562                 :    3976630 :   for (j = 1; j < decoded_options_count; j++)
    4563                 :            :     {
    4564                 :    3773890 :       if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
    4565                 :            :         {
    4566                 :     219695 :           const char *arg = decoded_options[j].arg;
    4567                 :     219695 :           const char *p = strrchr (arg, '@');
    4568                 :     219695 :           char *fname;
    4569                 :     219695 :           long offset;
    4570                 :     219695 :           int consumed;
    4571                 :            : #ifdef HAVE_TARGET_OBJECT_SUFFIX
    4572                 :            :           arg = convert_filename (arg, 0, access (arg, F_OK));
    4573                 :            : #endif
    4574                 :            :           /* For LTO static archive support we handle input file
    4575                 :            :              specifications that are composed of a filename and
    4576                 :            :              an offset like FNAME@OFFSET.  */
    4577                 :     219695 :           if (p
    4578                 :     219695 :               && p != arg
    4579                 :         25 :               && sscanf (p, "@%li%n", &offset, &consumed) >= 1
    4580                 :     219695 :               && strlen (p) == (unsigned int)consumed)
    4581                 :            :             {
    4582                 :          0 :               fname = (char *)xmalloc (p - arg + 1);
    4583                 :          0 :               memcpy (fname, arg, p - arg);
    4584                 :          0 :               fname[p - arg] = '\0';
    4585                 :            :               /* Only accept non-stdin and existing FNAME parts, otherwise
    4586                 :            :                  try with the full name.  */
    4587                 :          0 :               if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
    4588                 :            :                 {
    4589                 :          0 :                   free (fname);
    4590                 :          0 :                   fname = xstrdup (arg);
    4591                 :            :                 }
    4592                 :            :             }
    4593                 :            :           else
    4594                 :     219695 :             fname = xstrdup (arg);
    4595                 :            : 
    4596                 :     219695 :           if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
    4597                 :            :             {
    4598                 :          0 :               bool resp = fname[0] == '@' && access (fname + 1, F_OK) < 0;
    4599                 :          0 :               error ("%s: %m", fname + resp);
    4600                 :            :             }
    4601                 :            :           else
    4602                 :     219695 :             add_infile (arg, spec_lang);
    4603                 :            : 
    4604                 :     219695 :           free (fname);
    4605                 :     219695 :           continue;
    4606                 :            :         }
    4607                 :            : 
    4608                 :    3554200 :       read_cmdline_option (&global_options, &global_options_set,
    4609                 :            :                            decoded_options + j, UNKNOWN_LOCATION,
    4610                 :            :                            CL_DRIVER, &handlers, global_dc);
    4611                 :            :     }
    4612                 :            : 
    4613                 :            :   /* If the user didn't specify any, default to all configured offload
    4614                 :            :      targets.  */
    4615                 :     202737 :   if (ENABLE_OFFLOADING && offload_targets == NULL)
    4616                 :            :     handle_foffload_option (OFFLOAD_TARGETS);
    4617                 :            : 
    4618                 :     202737 :   if (output_file
    4619                 :     202737 :       && strcmp (output_file, "-") != 0
    4620                 :     191861 :       && strcmp (output_file, HOST_BIT_BUCKET) != 0)
    4621                 :            :     {
    4622                 :            :       int i;
    4623                 :     557540 :       for (i = 0; i < n_infiles; i++)
    4624                 :     174001 :         if ((!infiles[i].language || infiles[i].language[0] != '*')
    4625                 :     383982 :             && canonical_filename_eq (infiles[i].name, output_file))
    4626                 :          1 :           fatal_error (input_location,
    4627                 :            :                        "input file %qs is the same as output file",
    4628                 :            :                        output_file);
    4629                 :            :     }
    4630                 :            : 
    4631                 :     202736 :   if (output_file != NULL && output_file[0] == '\0')
    4632                 :          0 :     fatal_error (input_location, "output filename may not be empty");
    4633                 :            : 
    4634                 :            :   /* If -save-temps=obj and -o name, create the prefix to use for %b.
    4635                 :            :      Otherwise just make -save-temps=obj the same as -save-temps=cwd.  */
    4636                 :     202736 :   if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
    4637                 :            :     {
    4638                 :          0 :       save_temps_length = strlen (save_temps_prefix);
    4639                 :          0 :       temp = strrchr (lbasename (save_temps_prefix), '.');
    4640                 :          0 :       if (temp)
    4641                 :            :         {
    4642                 :          0 :           save_temps_length -= strlen (temp);
    4643                 :          0 :           save_temps_prefix[save_temps_length] = '\0';
    4644                 :            :         }
    4645                 :            : 
    4646                 :            :     }
    4647                 :     202736 :   else if (save_temps_prefix != NULL)
    4648                 :            :     {
    4649                 :     191880 :       free (save_temps_prefix);
    4650                 :     191880 :       save_temps_prefix = NULL;
    4651                 :            :     }
    4652                 :            : 
    4653                 :     202736 :   if (save_temps_flag && use_pipes)
    4654                 :            :     {
    4655                 :            :       /* -save-temps overrides -pipe, so that temp files are produced */
    4656                 :          0 :       if (save_temps_flag)
    4657                 :          0 :         warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
    4658                 :          0 :       use_pipes = 0;
    4659                 :            :     }
    4660                 :            : 
    4661                 :     202736 :   if (!compare_debug)
    4662                 :            :     {
    4663                 :     201939 :       const char *gcd = env.get ("GCC_COMPARE_DEBUG");
    4664                 :            : 
    4665                 :     201939 :       if (gcd && gcd[0] == '-')
    4666                 :            :         {
    4667                 :          0 :           compare_debug = 2;
    4668                 :          0 :           compare_debug_opt = gcd;
    4669                 :            :         }
    4670                 :     201939 :       else if (gcd && *gcd && strcmp (gcd, "0"))
    4671                 :            :         {
    4672                 :          0 :           compare_debug = 3;
    4673                 :          0 :           compare_debug_opt = "-gtoggle";
    4674                 :            :         }
    4675                 :            :     }
    4676                 :        797 :   else if (compare_debug < 0)
    4677                 :            :     {
    4678                 :          0 :       compare_debug = 0;
    4679                 :          0 :       gcc_assert (!compare_debug_opt);
    4680                 :            :     }
    4681                 :            : 
    4682                 :            :   /* Set up the search paths.  We add directories that we expect to
    4683                 :            :      contain GNU Toolchain components before directories specified by
    4684                 :            :      the machine description so that we will find GNU components (like
    4685                 :            :      the GNU assembler) before those of the host system.  */
    4686                 :            : 
    4687                 :            :   /* If we don't know where the toolchain has been installed, use the
    4688                 :            :      configured-in locations.  */
    4689                 :     202736 :   if (!gcc_exec_prefix)
    4690                 :            :     {
    4691                 :            : #ifndef OS2
    4692                 :          0 :       add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
    4693                 :            :                   PREFIX_PRIORITY_LAST, 1, 0);
    4694                 :          0 :       add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
    4695                 :            :                   PREFIX_PRIORITY_LAST, 2, 0);
    4696                 :          0 :       add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
    4697                 :            :                   PREFIX_PRIORITY_LAST, 2, 0);
    4698                 :            : #endif
    4699                 :          0 :       add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
    4700                 :            :                   PREFIX_PRIORITY_LAST, 1, 0);
    4701                 :            :     }
    4702                 :            : 
    4703                 :     202736 :   gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
    4704                 :     202736 :   tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
    4705                 :            :                             dir_separator_str, NULL);
    4706                 :            : 
    4707                 :            :   /* Look for tools relative to the location from which the driver is
    4708                 :            :      running, or, if that is not available, the configured prefix.  */
    4709                 :     202736 :   tooldir_prefix
    4710                 :     405472 :     = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
    4711                 :            :               spec_host_machine, dir_separator_str, spec_version,
    4712                 :            :               accel_dir_suffix, dir_separator_str, tooldir_prefix2, NULL);
    4713                 :     202736 :   free (tooldir_prefix2);
    4714                 :            : 
    4715                 :     202736 :   add_prefix (&exec_prefixes,
    4716                 :     202736 :               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
    4717                 :            :               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
    4718                 :     202736 :   add_prefix (&startfile_prefixes,
    4719                 :     202736 :               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
    4720                 :            :               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
    4721                 :     202736 :   free (tooldir_prefix);
    4722                 :            : 
    4723                 :            : #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
    4724                 :            :   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
    4725                 :            :      then consider it to relocate with the rest of the GCC installation
    4726                 :            :      if GCC_EXEC_PREFIX is set.
    4727                 :            :      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
    4728                 :            :   if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
    4729                 :            :     {
    4730                 :            :       char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
    4731                 :            :                                               standard_bindir_prefix,
    4732                 :            :                                               target_system_root);
    4733                 :            :       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
    4734                 :            :         {
    4735                 :            :           target_system_root = tmp_prefix;
    4736                 :            :           target_system_root_changed = 1;
    4737                 :            :         }
    4738                 :            :     }
    4739                 :            : #endif
    4740                 :            : 
    4741                 :            :   /* More prefixes are enabled in main, after we read the specs file
    4742                 :            :      and determine whether this is cross-compilation or not.  */
    4743                 :            : 
    4744                 :     202736 :   if (n_infiles != 0 && n_infiles == last_language_n_infiles && spec_lang != 0)
    4745                 :          0 :     warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
    4746                 :            : 
    4747                 :            :   /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
    4748                 :            :      environment variable.  */
    4749                 :     202736 :   if (compare_debug == 2 || compare_debug == 3)
    4750                 :            :     {
    4751                 :          0 :       const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
    4752                 :          0 :       save_switch (opt, 0, NULL, false, true);
    4753                 :          0 :       compare_debug = 1;
    4754                 :            :     }
    4755                 :            : 
    4756                 :            :   /* Ensure we only invoke each subprocess once.  */
    4757                 :     202736 :   if (n_infiles == 0
    4758                 :       2756 :       && (print_subprocess_help || print_help_list || print_version))
    4759                 :            :     {
    4760                 :            :       /* Create a dummy input file, so that we can pass
    4761                 :            :          the help option on to the various sub-processes.  */
    4762                 :         64 :       add_infile ("help-dummy", "c");
    4763                 :            :     }
    4764                 :            : 
    4765                 :            :   /* Decide if undefined variable references are allowed in specs.  */
    4766                 :            : 
    4767                 :            :   /* -v alone is safe. --version and --help alone or together are safe.  Note
    4768                 :            :      that -v would make them unsafe, as they'd then be run for subprocesses as
    4769                 :            :      well, the location of which might depend on variables possibly coming
    4770                 :            :      from self-specs.  Note also that the command name is counted in
    4771                 :            :      decoded_options_count.  */
    4772                 :            : 
    4773                 :     202736 :   unsigned help_version_count = 0;
    4774                 :            : 
    4775                 :     202736 :   if (print_version)
    4776                 :         64 :     help_version_count++;
    4777                 :            : 
    4778                 :     202736 :   if (print_help_list)
    4779                 :          4 :     help_version_count++;
    4780                 :            : 
    4781                 :     405472 :   spec_undefvar_allowed =
    4782                 :        762 :     ((verbose_flag && decoded_options_count == 2)
    4783                 :     203471 :      || help_version_count == decoded_options_count - 1);
    4784                 :            : 
    4785                 :     202736 :   alloc_switch ();
    4786                 :     202736 :   switches[n_switches].part1 = 0;
    4787                 :     202736 :   alloc_infile ();
    4788                 :     202736 :   infiles[n_infiles].name = 0;
    4789                 :     202736 : }
    4790                 :            : 
    4791                 :            : /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
    4792                 :            :    and place that in the environment.  */
    4793                 :            : 
    4794                 :            : static void
    4795                 :     584805 : set_collect_gcc_options (void)
    4796                 :            : {
    4797                 :     584805 :   int i;
    4798                 :     584805 :   int first_time;
    4799                 :            : 
    4800                 :            :   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
    4801                 :            :      the compiler.  */
    4802                 :     584805 :   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
    4803                 :            :                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
    4804                 :            : 
    4805                 :     584805 :   first_time = TRUE;
    4806                 :   11571200 :   for (i = 0; (int) i < n_switches; i++)
    4807                 :            :     {
    4808                 :   10986400 :       const char *const *args;
    4809                 :   10986400 :       const char *p, *q;
    4810                 :   10986400 :       if (!first_time)
    4811                 :   10401600 :         obstack_grow (&collect_obstack, " ", 1);
    4812                 :            : 
    4813                 :   10986400 :       first_time = FALSE;
    4814                 :            : 
    4815                 :            :       /* Ignore elided switches.  */
    4816                 :   10987200 :       if ((switches[i].live_cond
    4817                 :   10986400 :            & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
    4818                 :            :           == SWITCH_IGNORE)
    4819                 :        809 :         continue;
    4820                 :            : 
    4821                 :   10985600 :       obstack_grow (&collect_obstack, "'-", 2);
    4822                 :   10985600 :       q = switches[i].part1;
    4823                 :   10985600 :       while ((p = strchr (q, '\'')))
    4824                 :            :         {
    4825                 :          0 :           obstack_grow (&collect_obstack, q, p - q);
    4826                 :          0 :           obstack_grow (&collect_obstack, "'\\''", 4);
    4827                 :          0 :           q = ++p;
    4828                 :            :         }
    4829                 :   10985600 :       obstack_grow (&collect_obstack, q, strlen (q));
    4830                 :   10985600 :       obstack_grow (&collect_obstack, "'", 1);
    4831                 :            : 
    4832                 :   14407600 :       for (args = switches[i].args; args && *args; args++)
    4833                 :            :         {
    4834                 :    3421970 :           obstack_grow (&collect_obstack, " '", 2);
    4835                 :    3421970 :           q = *args;
    4836                 :    3421970 :           while ((p = strchr (q, '\'')))
    4837                 :            :             {
    4838                 :          0 :               obstack_grow (&collect_obstack, q, p - q);
    4839                 :          0 :               obstack_grow (&collect_obstack, "'\\''", 4);
    4840                 :          0 :               q = ++p;
    4841                 :            :             }
    4842                 :    3421970 :           obstack_grow (&collect_obstack, q, strlen (q));
    4843                 :    3421970 :           obstack_grow (&collect_obstack, "'", 1);
    4844                 :            :         }
    4845                 :            :     }
    4846                 :     584805 :   obstack_grow (&collect_obstack, "\0", 1);
    4847                 :     584805 :   xputenv (XOBFINISH (&collect_obstack, char *));
    4848                 :     584805 : }
    4849                 :            : 
    4850                 :            : /* Process a spec string, accumulating and running commands.  */
    4851                 :            : 
    4852                 :            : /* These variables describe the input file name.
    4853                 :            :    input_file_number is the index on outfiles of this file,
    4854                 :            :    so that the output file name can be stored for later use by %o.
    4855                 :            :    input_basename is the start of the part of the input file
    4856                 :            :    sans all directory names, and basename_length is the number
    4857                 :            :    of characters starting there excluding the suffix .c or whatever.  */
    4858                 :            : 
    4859                 :            : static const char *gcc_input_filename;
    4860                 :            : static int input_file_number;
    4861                 :            : size_t input_filename_length;
    4862                 :            : static int basename_length;
    4863                 :            : static int suffixed_basename_length;
    4864                 :            : static const char *input_basename;
    4865                 :            : static const char *input_suffix;
    4866                 :            : #ifndef HOST_LACKS_INODE_NUMBERS
    4867                 :            : static struct stat input_stat;
    4868                 :            : #endif
    4869                 :            : static int input_stat_set;
    4870                 :            : 
    4871                 :            : /* The compiler used to process the current input file.  */
    4872                 :            : static struct compiler *input_file_compiler;
    4873                 :            : 
    4874                 :            : /* These are variables used within do_spec and do_spec_1.  */
    4875                 :            : 
    4876                 :            : /* Nonzero if an arg has been started and not yet terminated
    4877                 :            :    (with space, tab or newline).  */
    4878                 :            : static int arg_going;
    4879                 :            : 
    4880                 :            : /* Nonzero means %d or %g has been seen; the next arg to be terminated
    4881                 :            :    is a temporary file name.  */
    4882                 :            : static int delete_this_arg;
    4883                 :            : 
    4884                 :            : /* Nonzero means %w has been seen; the next arg to be terminated
    4885                 :            :    is the output file name of this compilation.  */
    4886                 :            : static int this_is_output_file;
    4887                 :            : 
    4888                 :            : /* Nonzero means %s has been seen; the next arg to be terminated
    4889                 :            :    is the name of a library file and we should try the standard
    4890                 :            :    search dirs for it.  */
    4891                 :            : static int this_is_library_file;
    4892                 :            : 
    4893                 :            : /* Nonzero means %T has been seen; the next arg to be terminated
    4894                 :            :    is the name of a linker script and we should try all of the
    4895                 :            :    standard search dirs for it.  If it is found insert a --script
    4896                 :            :    command line switch and then substitute the full path in place,
    4897                 :            :    otherwise generate an error message.  */
    4898                 :            : static int this_is_linker_script;
    4899                 :            : 
    4900                 :            : /* Nonzero means that the input of this command is coming from a pipe.  */
    4901                 :            : static int input_from_pipe;
    4902                 :            : 
    4903                 :            : /* Nonnull means substitute this for any suffix when outputting a switches
    4904                 :            :    arguments.  */
    4905                 :            : static const char *suffix_subst;
    4906                 :            : 
    4907                 :            : /* If there is an argument being accumulated, terminate it and store it.  */
    4908                 :            : 
    4909                 :            : static void
    4910                 :   53830900 : end_going_arg (void)
    4911                 :            : {
    4912                 :   53830900 :   if (arg_going)
    4913                 :            :     {
    4914                 :   12301800 :       const char *string;
    4915                 :            : 
    4916                 :   12301800 :       obstack_1grow (&obstack, 0);
    4917                 :   12301800 :       string = XOBFINISH (&obstack, const char *);
    4918                 :   12301800 :       if (this_is_library_file)
    4919                 :   12715400 :         string = find_file (string);
    4920                 :   12301800 :       if (this_is_linker_script)
    4921                 :            :         {
    4922                 :          0 :           char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
    4923                 :            : 
    4924                 :          0 :           if (full_script_path == NULL)
    4925                 :            :             {
    4926                 :          0 :               error ("unable to locate default linker script %qs in the library search paths", string);
    4927                 :            :               /* Script was not found on search path.  */
    4928                 :          0 :               return;
    4929                 :            :             }
    4930                 :          0 :           store_arg ("--script", false, false);
    4931                 :          0 :           string = full_script_path;
    4932                 :            :         }
    4933                 :   12301800 :       store_arg (string, delete_this_arg, this_is_output_file);
    4934                 :   12301800 :       if (this_is_output_file)
    4935                 :      74678 :         outfiles[input_file_number] = string;
    4936                 :   12301800 :       arg_going = 0;
    4937                 :            :     }
    4938                 :            : }
    4939                 :            : 
    4940                 :            : 
    4941                 :            : /* Parse the WRAPPER string which is a comma separated list of the command line
    4942                 :            :    and insert them into the beginning of argbuf.  */
    4943                 :            : 
    4944                 :            : static void
    4945                 :          0 : insert_wrapper (const char *wrapper)
    4946                 :            : {
    4947                 :          0 :   int n = 0;
    4948                 :          0 :   int i;
    4949                 :          0 :   char *buf = xstrdup (wrapper);
    4950                 :          0 :   char *p = buf;
    4951                 :          0 :   unsigned int old_length = argbuf.length ();
    4952                 :            : 
    4953                 :          0 :   do
    4954                 :            :     {
    4955                 :          0 :       n++;
    4956                 :          0 :       while (*p == ',')
    4957                 :          0 :         p++;
    4958                 :            :     }
    4959                 :          0 :   while ((p = strchr (p, ',')) != NULL);
    4960                 :            : 
    4961                 :          0 :   argbuf.safe_grow (old_length + n);
    4962                 :          0 :   memmove (argbuf.address () + n,
    4963                 :          0 :            argbuf.address (),
    4964                 :          0 :            old_length * sizeof (const_char_p));
    4965                 :            : 
    4966                 :          0 :   i = 0;
    4967                 :          0 :   p = buf;
    4968                 :          0 :   do
    4969                 :            :     {
    4970                 :          0 :       while (*p == ',')
    4971                 :            :         {
    4972                 :          0 :           *p = 0;
    4973                 :          0 :           p++;
    4974                 :            :         }
    4975                 :          0 :       argbuf[i] = p;
    4976                 :          0 :       i++;
    4977                 :            :     }
    4978                 :          0 :   while ((p = strchr (p, ',')) != NULL);
    4979                 :          0 :   gcc_assert (i == n);
    4980                 :          0 : }
    4981                 :            : 
    4982                 :            : /* Process the spec SPEC and run the commands specified therein.
    4983                 :            :    Returns 0 if the spec is successfully processed; -1 if failed.  */
    4984                 :            : 
    4985                 :            : int
    4986                 :     396063 : do_spec (const char *spec)
    4987                 :            : {
    4988                 :     396063 :   int value;
    4989                 :            : 
    4990                 :     396063 :   value = do_spec_2 (spec, NULL);
    4991                 :            : 
    4992                 :            :   /* Force out any unfinished command.
    4993                 :            :      If -pipe, this forces out the last command if it ended in `|'.  */
    4994                 :     396063 :   if (value == 0)
    4995                 :            :     {
    4996                 :     391934 :       if (argbuf.length () > 0
    4997                 :     391934 :           && !strcmp (argbuf.last (), "|"))
    4998                 :          0 :         argbuf.pop ();
    4999                 :            : 
    5000                 :     391934 :       set_collect_gcc_options ();
    5001                 :            : 
    5002                 :     391934 :       if (argbuf.length () > 0)
    5003                 :     196844 :         value = execute ();
    5004                 :            :     }
    5005                 :            : 
    5006                 :     396063 :   return value;
    5007                 :            : }
    5008                 :            : 
    5009                 :            : /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
    5010                 :            :    of a matched * pattern which may be re-injected by way of %*.  */
    5011                 :            : 
    5012                 :            : static int
    5013                 :    2927660 : do_spec_2 (const char *spec, const char *soft_matched_part)
    5014                 :            : {
    5015                 :    2927660 :   int result;
    5016                 :            : 
    5017                 :    2927660 :   clear_args ();
    5018                 :    2927660 :   arg_going = 0;
    5019                 :    2927660 :   delete_this_arg = 0;
    5020                 :    2927660 :   this_is_output_file = 0;
    5021                 :    2927660 :   this_is_library_file = 0;
    5022                 :    2927660 :   this_is_linker_script = 0;
    5023                 :    2927660 :   input_from_pipe = 0;
    5024                 :    2927660 :   suffix_subst = NULL;
    5025                 :            : 
    5026                 :    2927660 :   result = do_spec_1 (spec, 0, soft_matched_part);
    5027                 :            : 
    5028                 :    2927660 :   end_going_arg ();
    5029                 :            : 
    5030                 :    2927660 :   return result;
    5031                 :            : }
    5032                 :            : 
    5033                 :            : /* Process the given spec string and add any new options to the end
    5034                 :            :    of the switches/n_switches array.  */
    5035                 :            : 
    5036                 :            : static void
    5037                 :    1825250 : do_option_spec (const char *name, const char *spec)
    5038                 :            : {
    5039                 :    1825250 :   unsigned int i, value_count, value_len;
    5040                 :    1825250 :   const char *p, *q, *value;
    5041                 :    1825250 :   char *tmp_spec, *tmp_spec_p;
    5042                 :            : 
    5043                 :    1825250 :   if (configure_default_options[0].name == NULL)
    5044                 :            :     return;
    5045                 :            : 
    5046                 :    4867340 :   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
    5047                 :    3447700 :     if (strcmp (configure_default_options[i].name, name) == 0)
    5048                 :            :       break;
    5049                 :    1825250 :   if (i == ARRAY_SIZE (configure_default_options))
    5050                 :            :     return;
    5051                 :            : 
    5052                 :     405612 :   value = configure_default_options[i].value;
    5053                 :     405612 :   value_len = strlen (value);
    5054                 :            : 
    5055                 :            :   /* Compute the size of the final spec.  */
    5056                 :     405612 :   value_count = 0;
    5057                 :     405612 :   p = spec;
    5058                 :     811224 :   while ((p = strstr (p, "%(VALUE)")) != NULL)
    5059                 :            :     {
    5060                 :     405612 :       p ++;
    5061                 :     405612 :       value_count ++;
    5062                 :            :     }
    5063                 :            : 
    5064                 :            :   /* Replace each %(VALUE) by the specified value.  */
    5065                 :     405612 :   tmp_spec = (char *) alloca (strlen (spec) + 1
    5066                 :            :                      + value_count * (value_len - strlen ("%(VALUE)")));
    5067                 :     405612 :   tmp_spec_p = tmp_spec;
    5068                 :     405612 :   q = spec;
    5069                 :     811224 :   while ((p = strstr (q, "%(VALUE)")) != NULL)
    5070                 :            :     {
    5071                 :     405612 :       memcpy (tmp_spec_p, q, p - q);
    5072                 :     405612 :       tmp_spec_p = tmp_spec_p + (p - q);
    5073                 :     405612 :       memcpy (tmp_spec_p, value, value_len);
    5074                 :     405612 :       tmp_spec_p += value_len;
    5075                 :     405612 :       q = p + strlen ("%(VALUE)");
    5076                 :            :     }
    5077                 :     405612 :   strcpy (tmp_spec_p, q);
    5078                 :            : 
    5079                 :     405612 :   do_self_spec (tmp_spec);
    5080                 :            : }
    5081                 :            : 
    5082                 :            : /* Process the given spec string and add any new options to the end
    5083                 :            :    of the switches/n_switches array.  */
    5084                 :            : 
    5085                 :            : static void
    5086                 :    1623620 : do_self_spec (const char *spec)
    5087                 :            : {
    5088                 :    1623620 :   int i;
    5089                 :            : 
    5090                 :    1623620 :   do_spec_2 (spec, NULL);
    5091                 :    1623620 :   do_spec_1 (" ", 0, NULL);
    5092                 :            : 
    5093                 :            :   /* Mark %<S switches processed by do_self_spec to be ignored permanently.
    5094                 :            :      do_self_specs adds the replacements to switches array, so it shouldn't
    5095                 :            :      be processed afterwards.  */
    5096                 :   30997400 :   for (i = 0; i < n_switches; i++)
    5097                 :   29373700 :     if ((switches[i].live_cond & SWITCH_IGNORE))
    5098                 :        815 :       switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
    5099                 :            : 
    5100                 :    1623620 :   if (argbuf.length () > 0)
    5101                 :            :     {
    5102                 :     385012 :       const char **argbuf_copy;
    5103                 :     385012 :       struct cl_decoded_option *decoded_options;
    5104                 :     385012 :       struct cl_option_handlers handlers;
    5105                 :     385012 :       unsigned int decoded_options_count;
    5106                 :     385012 :       unsigned int j;
    5107                 :            : 
    5108                 :            :       /* Create a copy of argbuf with a dummy argv[0] entry for
    5109                 :            :          decode_cmdline_options_to_array.  */
    5110                 :     385012 :       argbuf_copy = XNEWVEC (const char *,
    5111                 :            :                              argbuf.length () + 1);
    5112                 :     385012 :       argbuf_copy[0] = "";
    5113                 :    1155040 :       memcpy (argbuf_copy + 1, argbuf.address (),
    5114                 :     770024 :               argbuf.length () * sizeof (const char *));
    5115                 :            : 
    5116                 :     770024 :       decode_cmdline_options_to_array (argbuf.length () + 1,
    5117                 :            :                                        argbuf_copy,
    5118                 :            :                                        CL_DRIVER, &decoded_options,
    5119                 :            :                                        &decoded_options_count);
    5120                 :     385012 :       free (argbuf_copy);
    5121                 :            : 
    5122                 :     385012 :       set_option_handlers (&handlers);
    5123                 :            : 
    5124                 :     773212 :       for (j = 1; j < decoded_options_count; j++)
    5125                 :            :         {
    5126                 :     388200 :           switch (decoded_options[j].opt_index)
    5127                 :            :             {
    5128                 :          0 :             case OPT_SPECIAL_input_file:
    5129                 :            :               /* Specs should only generate options, not input
    5130                 :            :                  files.  */
    5131                 :          0 :               if (strcmp (decoded_options[j].arg, "-") != 0)
    5132                 :          0 :                 fatal_error (input_location,
    5133                 :            :                              "switch %qs does not start with %<-%>",
    5134                 :            :                              decoded_options[j].arg);
    5135                 :            :               else
    5136                 :          0 :                 fatal_error (input_location,
    5137                 :            :                              "spec-generated switch is just %<-%>");
    5138                 :       1594 :               break;
    5139                 :            : 
    5140                 :       1594 :             case OPT_fcompare_debug_second:
    5141                 :       1594 :             case OPT_fcompare_debug:
    5142                 :       1594 :             case OPT_fcompare_debug_:
    5143                 :       1594 :             case OPT_o:
    5144                 :            :               /* Avoid duplicate processing of some options from
    5145                 :            :                  compare-debug specs; just save them here.  */
    5146                 :       1594 :               save_switch (decoded_options[j].canonical_option[0],
    5147                 :       1594 :                            (decoded_options[j].canonical_option_num_elements
    5148                 :            :                             - 1),
    5149                 :       1594 :                            &decoded_options[j].canonical_option[1], false, true);
    5150                 :       1594 :               break;
    5151                 :            : 
    5152                 :     386606 :             default:
    5153                 :     386606 :               read_cmdline_option (&global_options, &global_options_set,
    5154                 :            :                                    decoded_options + j, UNKNOWN_LOCATION,
    5155                 :            :                                    CL_DRIVER, &handlers, global_dc);
    5156                 :     386606 :               break;
    5157                 :            :             }
    5158                 :            :         }
    5159                 :            : 
    5160                 :     385012 :       free (decoded_options);
    5161                 :            : 
    5162                 :     385012 :       alloc_switch ();
    5163                 :     385012 :       switches[n_switches].part1 = 0;
    5164                 :            :     }
    5165                 :    1623620 : }
    5166                 :            : 
    5167                 :            : /* Callback for processing %D and %I specs.  */
    5168                 :            : 
    5169                 :            : struct spec_path_info {
    5170                 :            :   const char *option;
    5171                 :            :   const char *append;
    5172                 :            :   size_t append_len;
    5173                 :            :   bool omit_relative;
    5174                 :            :   bool separate_options;
    5175                 :            : };
    5176                 :            : 
    5177                 :            : static void *
    5178                 :    2511330 : spec_path (char *path, void *data)
    5179                 :            : {
    5180                 :    2511330 :   struct spec_path_info *info = (struct spec_path_info *) data;
    5181                 :    2511330 :   size_t len = 0;
    5182                 :    2511330 :   char save = 0;
    5183                 :            : 
    5184                 :    2511330 :   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
    5185                 :            :     return NULL;
    5186                 :            : 
    5187                 :    2511330 :   if (info->append_len != 0)
    5188                 :            :     {
    5189                 :     997008 :       len = strlen (path);
    5190                 :     997008 :       memcpy (path + len, info->append, info->append_len + 1);
    5191                 :            :     }
    5192                 :            : 
    5193                 :    2511330 :   if (!is_directory (path, true))
    5194                 :            :     return NULL;
    5195                 :            : 
    5196                 :     787293 :   do_spec_1 (info->option, 1, NULL);
    5197                 :     787293 :   if (info->separate_options)
    5198                 :     315687 :     do_spec_1 (" ", 0, NULL);
    5199                 :            : 
    5200                 :     787293 :   if (info->append_len == 0)
    5201                 :            :     {
    5202                 :     471606 :       len = strlen (path);
    5203                 :     471606 :       save = path[len - 1];
    5204                 :     471606 :       if (IS_DIR_SEPARATOR (path[len - 1]))
    5205                 :     471606 :         path[len - 1] = '\0';
    5206                 :            :     }
    5207                 :            : 
    5208                 :     787293 :   do_spec_1 (path, 1, NULL);
    5209                 :     787293 :   do_spec_1 (" ", 0, NULL);
    5210                 :            : 
    5211                 :            :   /* Must not damage the original path.  */
    5212                 :     787293 :   if (info->append_len == 0)
    5213                 :     471606 :     path[len - 1] = save;
    5214                 :            : 
    5215                 :            :   return NULL;
    5216                 :            : }
    5217                 :            : 
    5218                 :            : /* True if we should compile INFILE. */
    5219                 :            : 
    5220                 :            : static bool
    5221                 :      27471 : compile_input_file_p (struct infile *infile)
    5222                 :            : {
    5223                 :      17195 :   if ((!infile->language) || (infile->language[0] != '*'))
    5224                 :      25222 :     if (infile->incompiler == input_file_compiler)
    5225                 :          0 :       return true;
    5226                 :            :   return false;
    5227                 :            : }
    5228                 :            : 
    5229                 :            : /* Process each member of VEC as a spec.  */
    5230                 :            : 
    5231                 :            : static void
    5232                 :     347447 : do_specs_vec (vec<char_p> vec)
    5233                 :            : {
    5234                 :     347447 :   unsigned ix;
    5235                 :     347447 :   char *opt;
    5236                 :            : 
    5237                 :     347502 :   FOR_EACH_VEC_ELT (vec, ix, opt)
    5238                 :            :     {
    5239                 :         55 :       do_spec_1 (opt, 1, NULL);
    5240                 :            :       /* Make each accumulated option a separate argument.  */
    5241                 :         55 :       do_spec_1 (" ", 0, NULL);
    5242                 :            :     }
    5243                 :     347447 : }
    5244                 :            : 
    5245                 :            : /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS.  */
    5246                 :            : 
    5247                 :            : static void
    5248                 :     202735 : putenv_COLLECT_AS_OPTIONS (vec<char_p> vec)
    5249                 :            : {
    5250                 :     202735 :   if (vec.is_empty ())
    5251                 :     202735 :      return;
    5252                 :            : 
    5253                 :         74 :   obstack_init (&collect_obstack);
    5254                 :         74 :   obstack_grow (&collect_obstack, "COLLECT_AS_OPTIONS=",
    5255                 :            :                 strlen ("COLLECT_AS_OPTIONS="));
    5256                 :            : 
    5257                 :         74 :   char *opt;
    5258                 :         74 :   unsigned ix;
    5259                 :            : 
    5260                 :        240 :   FOR_EACH_VEC_ELT (vec, ix, opt)
    5261                 :            :     {
    5262                 :        166 :       obstack_1grow (&collect_obstack, '\'');
    5263                 :        166 :       obstack_grow (&collect_obstack, opt, strlen (opt));
    5264                 :        166 :       obstack_1grow (&collect_obstack, '\'');
    5265                 :        166 :       if (ix < vec.length () - 1)
    5266                 :         92 :         obstack_1grow(&collect_obstack, ' ');
    5267                 :            :     }
    5268                 :            : 
    5269                 :         74 :   obstack_1grow (&collect_obstack, '\0');
    5270                 :         74 :   xputenv (XOBFINISH (&collect_obstack, char *));
    5271                 :            : }
    5272                 :            : 
    5273                 :            : /* Process the sub-spec SPEC as a portion of a larger spec.
    5274                 :            :    This is like processing a whole spec except that we do
    5275                 :            :    not initialize at the beginning and we do not supply a
    5276                 :            :    newline by default at the end.
    5277                 :            :    INSWITCH nonzero means don't process %-sequences in SPEC;
    5278                 :            :    in this case, % is treated as an ordinary character.
    5279                 :            :    This is used while substituting switches.
    5280                 :            :    INSWITCH nonzero also causes SPC not to terminate an argument.
    5281                 :            : 
    5282                 :            :    Value is zero unless a line was finished
    5283                 :            :    and the command on that line reported an error.  */
    5284                 :            : 
    5285                 :            : static int
    5286                 :   34151800 : do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
    5287                 :            : {
    5288                 :   34151800 :   const char *p = spec;
    5289                 :   34151800 :   int c;
    5290                 :   34151800 :   int i;
    5291                 :   34151800 :   int value;
    5292                 :            : 
    5293                 :            :   /* If it's an empty string argument to a switch, keep it as is.  */
    5294                 :   34151800 :   if (inswitch && !*p)
    5295                 :          1 :     arg_going = 1;
    5296                 :            : 
    5297                 :  371245000 :   while ((c = *p++))
    5298                 :            :     /* If substituting a switch, treat all chars like letters.
    5299                 :            :        Otherwise, NL, SPC, TAB and % are special.  */
    5300                 :  337126000 :     switch (inswitch ? 'a' : c)
    5301                 :            :       {
    5302                 :     192871 :       case '\n':
    5303                 :     192871 :         end_going_arg ();
    5304                 :            : 
    5305                 :     192871 :         if (argbuf.length () > 0
    5306                 :     192871 :             && !strcmp (argbuf.last (), "|"))
    5307                 :            :           {
    5308                 :            :             /* A `|' before the newline means use a pipe here,
    5309                 :            :                but only if -pipe was specified.
    5310                 :            :                Otherwise, execute now and don't pass the `|' as an arg.  */
    5311                 :     120007 :             if (use_pipes)
    5312                 :            :               {
    5313                 :          0 :                 input_from_pipe = 1;
    5314                 :          0 :                 break;
    5315                 :            :               }
    5316                 :            :             else
    5317                 :     120007 :               argbuf.pop ();
    5318                 :            :           }
    5319                 :            : 
    5320                 :     192871 :         set_collect_gcc_options ();
    5321                 :            : 
    5322                 :     192871 :         if (argbuf.length () > 0)
    5323                 :            :           {
    5324                 :     192871 :             value = execute ();
    5325                 :     192871 :             if (value)
    5326                 :       4129 :               return value;
    5327                 :            :           }
    5328                 :            :         /* Reinitialize for a new command, and for a new argument.  */
    5329                 :     188742 :         clear_args ();
    5330                 :     188742 :         arg_going = 0;
    5331                 :     188742 :         delete_this_arg = 0;
    5332                 :     188742 :         this_is_output_file = 0;
    5333                 :     188742 :         this_is_library_file = 0;
    5334                 :     188742 :         this_is_linker_script = 0;
    5335                 :     188742 :         input_from_pipe = 0;
    5336                 :     188742 :         break;
    5337                 :            : 
    5338                 :     120007 :       case '|':
    5339                 :     120007 :         end_going_arg ();
    5340                 :            : 
    5341                 :            :         /* Use pipe */
    5342                 :     120007 :         obstack_1grow (&obstack, c);
    5343                 :     120007 :         arg_going = 1;
    5344                 :     120007 :         break;
    5345                 :            : 
    5346                 :   48025200 :       case '\t':
    5347                 :   48025200 :       case ' ':
    5348                 :   48025200 :         end_going_arg ();
    5349                 :            : 
    5350                 :            :         /* Reinitialize for a new argument.  */
    5351                 :   48025200 :         delete_this_arg = 0;
    5352                 :   48025200 :         this_is_output_file = 0;
    5353                 :   48025200 :         this_is_library_file = 0;
    5354                 :   48025200 :         this_is_linker_script = 0;
    5355                 :   48025200 :         break;
    5356                 :            : 
    5357                 :   35348000 :       case '%':
    5358                 :   35348000 :         switch (c = *p++)
    5359                 :            :           {
    5360                 :          0 :           case 0:
    5361                 :          0 :             fatal_error (input_location, "spec %qs invalid", spec);
    5362                 :            : 
    5363                 :      82422 :           case 'b':
    5364                 :      82422 :             if (save_temps_length)
    5365                 :          0 :               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
    5366                 :            :             else
    5367                 :      82422 :               obstack_grow (&obstack, input_basename, basename_length);
    5368                 :      82422 :             if (compare_debug < 0)
    5369                 :        795 :               obstack_grow (&obstack, ".gk", 3);
    5370                 :      82422 :             arg_going = 1;
    5371                 :      82422 :             break;
    5372                 :            : 
    5373                 :     184137 :           case 'B':
    5374                 :     184137 :             if (save_temps_length)
    5375                 :          0 :               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
    5376                 :            :             else
    5377                 :     184137 :               obstack_grow (&obstack, input_basename, suffixed_basename_length);
    5378                 :     184137 :             if (compare_debug < 0)
    5379                 :        795 :               obstack_grow (&obstack, ".gk", 3);
    5380                 :     184137 :             arg_going = 1;
    5381                 :     184137 :             break;
    5382                 :            : 
    5383                 :      73065 :           case 'd':
    5384                 :      73065 :             delete_this_arg = 2;
    5385                 :      73065 :             break;
    5386                 :            : 
    5387                 :            :           /* Dump out the directories specified with LIBRARY_PATH,
    5388                 :            :              followed by the absolute directories
    5389                 :            :              that we search for startfiles.  */
    5390                 :      76556 :           case 'D':
    5391                 :      76556 :             {
    5392                 :      76556 :               struct spec_path_info info;
    5393                 :            : 
    5394                 :      76556 :               info.option = "-L";
    5395                 :      76556 :               info.append_len = 0;
    5396                 :            : #ifdef RELATIVE_PREFIX_NOT_LINKDIR
    5397                 :            :               /* Used on systems which record the specified -L dirs
    5398                 :            :                  and use them to search for dynamic linking.
    5399                 :            :                  Relative directories always come from -B,
    5400                 :            :                  and it is better not to use them for searching
    5401                 :            :                  at run time.  In particular, stage1 loses.  */
    5402                 :            :               info.omit_relative = true;
    5403                 :            : #else
    5404                 :      76556 :               info.omit_relative = false;
    5405                 :            : #endif
    5406                 :      76556 :               info.separate_options = false;
    5407                 :            : 
    5408                 :      76556 :               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
    5409                 :            :             }
    5410                 :      76556 :             break;
    5411                 :            : 
    5412                 :            :           case 'e':
    5413                 :            :             /* %efoo means report an error with `foo' as error message
    5414                 :            :                and don't execute any more commands for this file.  */
    5415                 :            :             {
    5416                 :          0 :               const char *q = p;
    5417                 :          0 :               char *buf;
    5418                 :          0 :               while (*p != 0 && *p != '\n')
    5419                 :          0 :                 p++;
    5420                 :          0 :               buf = (char *) alloca (p - q + 1);
    5421                 :          0 :               strncpy (buf, q, p - q);
    5422                 :          0 :               buf[p - q] = 0;
    5423                 :          0 :               error ("%s", _(buf));
    5424                 :          0 :               return -1;
    5425                 :            :             }
    5426                 :            :             break;
    5427                 :            :           case 'n':
    5428                 :            :             /* %nfoo means report a notice with `foo' on stderr.  */
    5429                 :            :             {
    5430                 :          0 :               const char *q = p;
    5431                 :          0 :               char *buf;
    5432                 :          0 :               while (*p != 0 && *p != '\n')
    5433                 :          0 :                 p++;
    5434                 :          0 :               buf = (char *) alloca (p - q + 1);
    5435                 :          0 :               strncpy (buf, q, p - q);
    5436                 :          0 :               buf[p - q] = 0;
    5437                 :          0 :               inform (UNKNOWN_LOCATION, "%s", _(buf));
    5438                 :          0 :               if (*p)
    5439                 :          0 :                 p++;
    5440                 :            :             }
    5441                 :            :             break;
    5442                 :            : 
    5443                 :        878 :           case 'j':
    5444                 :        878 :             {
    5445                 :        878 :               struct stat st;
    5446                 :            : 
    5447                 :            :               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
    5448                 :            :                  defined, and it is not a directory, and it is
    5449                 :            :                  writable, use it.  Otherwise, treat this like any
    5450                 :            :                  other temporary file.  */
    5451                 :            : 
    5452                 :        878 :               if ((!save_temps_flag)
    5453                 :        878 :                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
    5454                 :       1756 :                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
    5455                 :            :                 {
    5456                 :        878 :                   obstack_grow (&obstack, HOST_BIT_BUCKET,
    5457                 :            :                                 strlen (HOST_BIT_BUCKET));
    5458                 :        878 :                   delete_this_arg = 0;
    5459                 :        878 :                   arg_going = 1;
    5460                 :        878 :                   break;
    5461                 :            :                 }
    5462                 :            :             }
    5463                 :          0 :             goto create_temp_file;
    5464                 :     120007 :           case '|':
    5465                 :     120007 :             if (use_pipes)
    5466                 :            :               {
    5467                 :          0 :                 obstack_1grow (&obstack, '-');
    5468                 :          0 :                 delete_this_arg = 0;
    5469                 :          0 :                 arg_going = 1;
    5470                 :            : 
    5471                 :            :                 /* consume suffix */
    5472                 :          0 :                 while (*p == '.' || ISALNUM ((unsigned char) *p))
    5473                 :          0 :                   p++;
    5474                 :          0 :                 if (p[0] == '%' && p[1] == 'O')
    5475                 :          0 :                   p += 2;
    5476                 :            : 
    5477                 :            :                 break;
    5478                 :            :               }
    5479                 :     120007 :             goto create_temp_file;
    5480                 :     116007 :           case 'm':
    5481                 :     116007 :             if (use_pipes)
    5482                 :            :               {
    5483                 :            :                 /* consume suffix */
    5484                 :          0 :                 while (*p == '.' || ISALNUM ((unsigned char) *p))
    5485                 :          0 :                   p++;
    5486                 :          0 :                 if (p[0] == '%' && p[1] == 'O')
    5487                 :          0 :                   p += 2;
    5488                 :            : 
    5489                 :            :                 break;
    5490                 :            :               }
    5491                 :     116007 :             goto create_temp_file;
    5492                 :     380255 :           case 'g':
    5493                 :     380255 :           case 'u':
    5494                 :     380255 :           case 'U':
    5495                 :     380255 :           create_temp_file:
    5496                 :     380255 :               {
    5497                 :     380255 :                 struct temp_name *t;
    5498                 :     380255 :                 int suffix_length;
    5499                 :     380255 :                 const char *suffix = p;
    5500                 :     380255 :                 char *saved_suffix = NULL;
    5501                 :            : 
    5502                 :    1136250 :                 while (*p == '.' || ISALNUM ((unsigned char) *p))
    5503                 :     755992 :                   p++;
    5504                 :     380255 :                 suffix_length = p - suffix;
    5505                 :     380255 :                 if (p[0] == '%' && p[1] == 'O')
    5506                 :            :                   {
    5507                 :      73065 :                     p += 2;
    5508                 :            :                     /* We don't support extra suffix characters after %O.  */
    5509                 :      73065 :                     if (*p == '.' || ISALNUM ((unsigned char) *p))
    5510                 :          0 :                       fatal_error (input_location,
    5511                 :            :                                    "spec %qs has invalid %<%%0%c%>", spec, *p);
    5512                 :      73065 :                     if (suffix_length == 0)
    5513                 :            :                       suffix = TARGET_OBJECT_SUFFIX;
    5514                 :            :                     else
    5515                 :            :                       {
    5516                 :          0 :                         saved_suffix
    5517                 :          0 :                           = XNEWVEC (char, suffix_length
    5518                 :            :                                      + strlen (TARGET_OBJECT_SUFFIX) + 1);
    5519                 :          0 :                         strncpy (saved_suffix, suffix, suffix_length);
    5520                 :          0 :                         strcpy (saved_suffix + suffix_length,
    5521                 :            :                                 TARGET_OBJECT_SUFFIX);
    5522                 :            :                       }
    5523                 :      73065 :                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
    5524                 :            :                   }
    5525                 :            : 
    5526                 :     380255 :                 if (compare_debug < 0)
    5527                 :            :                   {
    5528                 :        795 :                     suffix = concat (".gk", suffix, NULL);
    5529                 :        795 :                     suffix_length += 3;
    5530                 :            :                   }
    5531                 :            : 
    5532                 :            :                 /* If -save-temps=obj and -o were specified, use that for the
    5533                 :            :                    temp file.  */
    5534                 :     380255 :                 if (save_temps_length)
    5535                 :            :                   {
    5536                 :          0 :                     char *tmp;
    5537                 :          0 :                     temp_filename_length
    5538                 :          0 :                       = save_temps_length + suffix_length + 1;
    5539                 :          0 :                     tmp = (char *) alloca (temp_filename_length);
    5540                 :          0 :                     memcpy (tmp, save_temps_prefix, save_temps_length);
    5541                 :          0 :                     memcpy (tmp + save_temps_length, suffix, suffix_length);
    5542                 :          0 :                     tmp[save_temps_length + suffix_length] = '\0';
    5543                 :          0 :                     temp_filename = save_string (tmp, save_temps_length
    5544                 :            :                                                       + suffix_length);
    5545                 :          0 :                     obstack_grow (&obstack, temp_filename,
    5546                 :            :                                   temp_filename_length);
    5547                 :          0 :                     arg_going = 1;
    5548                 :          0 :                     delete_this_arg = 0;
    5549                 :          0 :                     break;
    5550                 :            :                   }
    5551                 :            : 
    5552                 :            :                 /* If the gcc_input_filename has the same suffix specified
    5553                 :            :                    for the %g, %u, or %U, and -save-temps is specified,
    5554                 :            :                    we could end up using that file as an intermediate
    5555                 :            :                    thus clobbering the user's source file (.e.g.,
    5556                 :            :                    gcc -save-temps foo.s would clobber foo.s with the
    5557                 :            :                    output of cpp0).  So check for this condition and
    5558                 :            :                    generate a temp file as the intermediate.  */
    5559                 :            : 
    5560                 :     380255 :                 if (save_temps_flag)
    5561                 :            :                   {
    5562                 :        261 :                     char *tmp;
    5563                 :        261 :                     temp_filename_length = basename_length + suffix_length + 1;
    5564                 :        261 :                     tmp = (char *) alloca (temp_filename_length);
    5565                 :        261 :                     memcpy (tmp, input_basename, basename_length);
    5566                 :        261 :                     memcpy (tmp + basename_length, suffix, suffix_length);
    5567                 :        261 :                     tmp[basename_length + suffix_length] = '\0';
    5568                 :        261 :                     temp_filename = tmp;
    5569                 :            : 
    5570                 :        261 :                     if (filename_cmp (temp_filename, gcc_input_filename) != 0)
    5571                 :            :                       {
    5572                 :            : #ifndef HOST_LACKS_INODE_NUMBERS
    5573                 :        261 :                         struct stat st_temp;
    5574                 :            : 
    5575                 :            :                         /* Note, set_input() resets input_stat_set to 0.  */
    5576                 :        261 :                         if (input_stat_set == 0)
    5577                 :            :                           {
    5578                 :        129 :                             input_stat_set = stat (gcc_input_filename,
    5579                 :            :                                                    &input_stat);
    5580                 :        129 :                             if (input_stat_set >= 0)
    5581                 :        129 :                               input_stat_set = 1;
    5582                 :            :                           }
    5583                 :            : 
    5584                 :            :                         /* If we have the stat for the gcc_input_filename
    5585                 :            :                            and we can do the stat for the temp_filename
    5586                 :            :                            then the they could still refer to the same
    5587                 :            :                            file if st_dev/st_ino's are the same.  */
    5588                 :        261 :                         if (input_stat_set != 1
    5589                 :        261 :                             || stat (temp_filename, &st_temp) < 0
    5590                 :         77 :                             || input_stat.st_dev != st_temp.st_dev
    5591                 :        338 :                             || input_stat.st_ino != st_temp.st_ino)
    5592                 :            : #else
    5593                 :            :                         /* Just compare canonical pathnames.  */
    5594                 :            :                         char* input_realname = lrealpath (gcc_input_filename);
    5595                 :            :                         char* temp_realname = lrealpath (temp_filename);
    5596                 :            :                         bool files_differ = filename_cmp (input_realname, temp_realname);
    5597                 :            :                         free (input_realname);
    5598                 :            :                         free (temp_realname);
    5599                 :            :                         if (files_differ)
    5600                 :            : #endif
    5601                 :            :                           {
    5602                 :        261 :                             temp_filename
    5603                 :        261 :                               = save_string (temp_filename,
    5604                 :            :                                              temp_filename_length - 1);
    5605                 :        261 :                             obstack_grow (&obstack, temp_filename,
    5606                 :            :                                                     temp_filename_length);
    5607                 :        261 :                             arg_going = 1;
    5608                 :        261 :                             delete_this_arg = 0;
    5609                 :        261 :                             break;
    5610                 :            :                           }
    5611                 :            :                       }
    5612                 :            :                   }
    5613                 :            : 
    5614                 :            :                 /* See if we already have an association of %g/%u/%U and
    5615                 :            :                    suffix.  */
    5616                 :     660312 :                 for (t = temp_names; t; t = t->next)
    5617                 :     400196 :                   if (t->length == suffix_length
    5618                 :     264525 :                       && strncmp (t->suffix, suffix, suffix_length) == 0
    5619                 :     237794 :                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
    5620                 :            :                     break;
    5621                 :            : 
    5622                 :            :                 /* Make a new association if needed.  %u and %j
    5623                 :            :                    require one.  */
    5624                 :     379994 :                 if (t == 0 || c == 'u' || c == 'j')
    5625                 :            :                   {
    5626                 :     262078 :                     if (t == 0)
    5627                 :            :                       {
    5628                 :     260116 :                         t = XNEW (struct temp_name);
    5629                 :     260116 :                         t->next = temp_names;
    5630                 :     260116 :                         temp_names = t;
    5631                 :            :                       }
    5632                 :     262078 :                     t->length = suffix_length;
    5633                 :     262078 :                     if (saved_suffix)
    5634                 :            :                       {
    5635                 :          0 :                         t->suffix = saved_suffix;
    5636                 :          0 :                         saved_suffix = NULL;
    5637                 :            :                       }
    5638                 :            :                     else
    5639                 :     262078 :                       t->suffix = save_string (suffix, suffix_length);
    5640                 :     262078 :                     t->unique = (c == 'u' || c == 'U' || c == 'j');
    5641                 :     262078 :                     temp_filename = make_temp_file (t->suffix);
    5642                 :     262078 :                     temp_filename_length = strlen (temp_filename);
    5643                 :     262078 :                     t->filename = temp_filename;
    5644                 :     262078 :                     t->filename_length = temp_filename_length;
    5645                 :            :                   }
    5646                 :            : 
    5647                 :     379994 :                 free (saved_suffix);
    5648                 :            : 
    5649                 :     379994 :                 obstack_grow (&obstack, t->filename, t->filename_length);
    5650                 :     379994 :                 delete_this_arg = 1;
    5651                 :            :               }
    5652                 :     379994 :             arg_going = 1;
    5653                 :     379994 :             break;
    5654                 :            : 
    5655                 :     201767 :           case 'i':
    5656                 :     201767 :             if (combine_inputs)
    5657                 :            :               {
    5658                 :            :                 /* We are going to expand `%i' into `@FILE', where FILE
    5659                 :            :                    is a newly-created temporary filename.  The filenames
    5660                 :            :                    that would usually be expanded in place of %o will be
    5661                 :            :                    written to the temporary file.  */
    5662                 :      17379 :                 if (at_file_supplied)
    5663                 :      13991 :                   open_at_file ();
    5664                 :            : 
    5665                 :      44850 :                 for (i = 0; (int) i < n_infiles; i++)
    5666                 :      54942 :                   if (compile_input_file_p (&infiles[i]))
    5667                 :            :                     {
    5668                 :      25189 :                       store_arg (infiles[i].name, 0, 0);
    5669                 :      25189 :                       infiles[i].compiled = true;
    5670                 :            :                     }
    5671                 :            : 
    5672                 :      17379 :                 if (at_file_supplied)
    5673                 :      13991 :                   close_at_file ();
    5674                 :            :               }
    5675                 :            :             else
    5676                 :            :               {
    5677                 :     184388 :                 obstack_grow (&obstack, gcc_input_filename,
    5678                 :            :                               input_filename_length);
    5679                 :     184388 :                 arg_going = 1;
    5680                 :            :               }
    5681                 :            :             break;
    5682                 :            : 
    5683                 :     157846 :           case 'I':
    5684                 :     157846 :             {
    5685                 :     157846 :               struct spec_path_info info;
    5686                 :            : 
    5687                 :     157846 :               if (multilib_dir)
    5688                 :            :                 {
    5689                 :       4687 :                   do_spec_1 ("-imultilib", 1, NULL);
    5690                 :            :                   /* Make this a separate argument.  */
    5691                 :       4687 :                   do_spec_1 (" ", 0, NULL);
    5692                 :       4687 :                   do_spec_1 (multilib_dir, 1, NULL);
    5693                 :       4687 :                   do_spec_1 (" ", 0, NULL);
    5694                 :            :                 }
    5695                 :            : 
    5696                 :     157846 :               if (multiarch_dir)
    5697                 :            :                 {
    5698                 :          0 :                   do_spec_1 ("-imultiarch", 1, NULL);
    5699                 :            :                   /* Make this a separate argument.  */
    5700                 :          0 :                   do_spec_1 (" ", 0, NULL);
    5701                 :          0 :                   do_spec_1 (multiarch_dir, 1, NULL);
    5702                 :          0 :                   do_spec_1 (" ", 0, NULL);
    5703                 :            :                 }
    5704                 :            : 
    5705                 :     157846 :               if (gcc_exec_prefix)
    5706                 :            :                 {
    5707                 :     157846 :                   do_spec_1 ("-iprefix", 1, NULL);
    5708                 :            :                   /* Make this a separate argument.  */
    5709                 :     157846 :                   do_spec_1 (" ", 0, NULL);
    5710                 :     157846 :                   do_spec_1 (gcc_exec_prefix, 1, NULL);
    5711                 :     157846 :                   do_spec_1 (" ", 0, NULL);
    5712                 :            :                 }
    5713                 :            : 
    5714                 :     315692 :               if (target_system_root_changed ||
    5715                 :     157846 :                   (target_system_root && target_sysroot_hdrs_suffix))
    5716                 :            :                 {
    5717                 :          0 :                   do_spec_1 ("-isysroot", 1, NULL);
    5718                 :            :                   /* Make this a separate argument.  */
    5719                 :          0 :                   do_spec_1 (" ", 0, NULL);
    5720                 :          0 :                   do_spec_1 (target_system_root, 1, NULL);
    5721                 :          0 :                   if (target_sysroot_hdrs_suffix)
    5722                 :          0 :                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
    5723                 :          0 :                   do_spec_1 (" ", 0, NULL);
    5724                 :            :                 }
    5725                 :            : 
    5726                 :     157846 :               info.option = "-isystem";
    5727                 :     157846 :               info.append = "include";
    5728                 :     157846 :               info.append_len = strlen (info.append);
    5729                 :     157846 :               info.omit_relative = false;
    5730                 :     157846 :               info.separate_options = true;
    5731                 :            : 
    5732                 :     157846 :               for_each_path (&include_prefixes, false, info.append_len,
    5733                 :            :                              spec_path, &info);
    5734                 :            : 
    5735                 :     157846 :               info.append = "include-fixed";
    5736                 :     157846 :               if (*sysroot_hdrs_suffix_spec)
    5737                 :          0 :                 info.append = concat (info.append, dir_separator_str,
    5738                 :            :                                       multilib_dir, NULL);
    5739                 :     157846 :               info.append_len = strlen (info.append);
    5740                 :     157846 :               for_each_path (&include_prefixes, false, info.append_len,
    5741                 :            :                              spec_path, &info);
    5742                 :            :             }
    5743                 :     157846 :             break;
    5744                 :            : 
    5745                 :      72727 :           case 'o':
    5746                 :            :             /* We are going to expand `%o' into `@FILE', where FILE
    5747                 :            :                is a newly-created temporary filename.  The filenames
    5748                 :            :                that would usually be expanded in place of %o will be
    5749                 :            :                written to the temporary file.  */
    5750                 :      72727 :             if (at_file_supplied)
    5751                 :          0 :               open_at_file ();
    5752                 :            : 
    5753                 :     314335 :             for (i = 0; i < n_infiles + lang_specific_extra_outfiles; i++)
    5754                 :     241608 :               if (outfiles[i])
    5755                 :     241569 :                 store_arg (outfiles[i], 0, 0);
    5756                 :            : 
    5757                 :      72727 :             if (at_file_supplied)
    5758                 :          0 :               close_at_file ();
    5759                 :            :             break;
    5760                 :            : 
    5761                 :       2823 :           case 'O':
    5762                 :       2823 :             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
    5763                 :       2823 :             arg_going = 1;
    5764                 :       2823 :             break;
    5765                 :            : 
    5766                 :     413701 :           case 's':
    5767                 :     413701 :             this_is_library_file = 1;
    5768                 :     413701 :             break;
    5769                 :            : 
    5770                 :          0 :           case 'T':
    5771                 :          0 :             this_is_linker_script = 1;
    5772                 :          0 :             break;
    5773                 :            : 
    5774                 :        346 :           case 'V':
    5775                 :        346 :             outfiles[input_file_number] = NULL;
    5776                 :        346 :             break;
    5777                 :            : 
    5778                 :      74678 :           case 'w':
    5779                 :      74678 :             this_is_output_file = 1;
    5780                 :      74678 :             break;
    5781                 :            : 
    5782                 :     118670 :           case 'W':
    5783                 :     118670 :             {
    5784                 :     118670 :               unsigned int cur_index = argbuf.length ();
    5785                 :            :               /* Handle the {...} following the %W.  */
    5786                 :     118670 :               if (*p != '{')
    5787                 :          0 :                 fatal_error (input_location,
    5788                 :            :                              "spec %qs has invalid %<%%W%c%>", spec, *p);
    5789                 :     118670 :               p = handle_braces (p + 1);
    5790                 :     118670 :               if (p == 0)
    5791                 :            :                 return -1;
    5792                 :     118670 :               end_going_arg ();
    5793                 :            :               /* If any args were output, mark the last one for deletion
    5794                 :            :                  on failure.  */
    5795                 :     237340 :               if (argbuf.length () != cur_index)
    5796                 :     116240 :                 record_temp_file (argbuf.last (), 0, 1);
    5797                 :            :               break;
    5798                 :            :             }
    5799                 :            : 
    5800                 :     230573 :           case '@':
    5801                 :            :             /* Handle the {...} following the %@.  */
    5802                 :     230573 :             if (*p != '{')
    5803                 :          0 :               fatal_error (input_location,
    5804                 :            :                            "spec %qs has invalid %<%%@%c%>", spec, *p);
    5805                 :     230573 :             if (at_file_supplied)
    5806                 :          0 :               open_at_file ();
    5807                 :     230573 :             p = handle_braces (p + 1);
    5808                 :     230573 :             if (at_file_supplied)
    5809                 :          0 :               close_at_file ();
    5810                 :     230573 :             if (p == 0)
    5811                 :            :               return -1;
    5812                 :            :             break;
    5813                 :            : 
    5814                 :            :           /* %x{OPTION} records OPTION for %X to output.  */
    5815                 :          0 :           case 'x':
    5816                 :          0 :             {
    5817                 :          0 :               const char *p1 = p;
    5818                 :          0 :               char *string;
    5819                 :          0 :               char *opt;
    5820                 :          0 :               unsigned ix;
    5821                 :            : 
    5822                 :            :               /* Skip past the option value and make a copy.  */
    5823                 :          0 :               if (*p != '{')
    5824                 :          0 :                 fatal_error (input_location,
    5825                 :            :                              "spec %qs has invalid %<%%x%c%>", spec, *p);
    5826                 :          0 :               while (*p++ != '}')
    5827                 :            :                 ;
    5828                 :          0 :               string = save_string (p1 + 1, p - p1 - 2);
    5829                 :            : 
    5830                 :            :               /* See if we already recorded this option.  */
    5831                 :          0 :               FOR_EACH_VEC_ELT (linker_options, ix, opt)
    5832                 :          0 :                 if (! strcmp (string, opt))
    5833                 :            :                   {
    5834                 :          0 :                     free (string);
    5835                 :          0 :                     return 0;
    5836                 :            :                   }
    5837                 :            : 
    5838                 :            :               /* This option is new; add it.  */
    5839                 :          0 :               add_linker_option (string, strlen (string));
    5840                 :          0 :               free (string);
    5841                 :            :             }
    5842                 :          0 :             break;
    5843                 :            : 
    5844                 :            :           /* Dump out the options accumulated previously using %x.  */
    5845                 :      72727 :           case 'X':
    5846                 :      72727 :             do_specs_vec (linker_options);
    5847                 :      72727 :             break;
    5848                 :            : 
    5849                 :            :           /* Dump out the options accumulated previously using -Wa,.  */
    5850                 :     116874 :           case 'Y':
    5851                 :     116874 :             do_specs_vec (assembler_options);
    5852                 :     116874 :             break;
    5853                 :            : 
    5854                 :            :           /* Dump out the options accumulated previously using -Wp,.  */
    5855                 :     157846 :           case 'Z':
    5856                 :     157846 :             do_specs_vec (preprocessor_options);
    5857                 :     157846 :             break;
    5858                 :            : 
    5859                 :            :             /* Here are digits and numbers that just process
    5860                 :            :                a certain constant string as a spec.  */
    5861                 :            : 
    5862                 :     200112 :           case '1':
    5863                 :     200112 :             value = do_spec_1 (cc1_spec, 0, NULL);
    5864                 :     200112 :             if (value != 0)
    5865                 :          0 :               return value;
    5866                 :            :             break;
    5867                 :            : 
    5868                 :      78292 :           case '2':
    5869                 :      78292 :             value = do_spec_1 (cc1plus_spec, 0, NULL);
    5870                 :      78292 :             if (value != 0)
    5871                 :          0 :               return value;
    5872                 :            :             break;
    5873                 :            : 
    5874                 :     116874 :           case 'a':
    5875                 :     116874 :             value = do_spec_1 (asm_spec, 0, NULL);
    5876                 :     116874 :             if (value != 0)
    5877                 :          0 :               return value;
    5878                 :            :             break;
    5879                 :            : 
    5880                 :     116874 :           case 'A':
    5881                 :     116874 :             value = do_spec_1 (asm_final_spec, 0, NULL);
    5882                 :     116874 :             if (value != 0)
    5883                 :          0 :               return value;
    5884                 :            :             break;
    5885                 :            : 
    5886                 :     157846 :           case 'C':
    5887                 :     157846 :             {
    5888                 :     315692 :               const char *const spec
    5889                 :     157846 :                 = (input_file_compiler->cpp_spec
    5890                 :     157846 :                    ? input_file_compiler->cpp_spec
    5891                 :            :                    : cpp_spec);
    5892                 :     157846 :               value = do_spec_1 (spec, 0, NULL);
    5893                 :     157846 :               if (value != 0)
    5894                 :          0 :                 return value;
    5895                 :            :             }
    5896                 :            :             break;
    5897                 :            : 
    5898                 :      72535 :           case 'E':
    5899                 :      72535 :             value = do_spec_1 (endfile_spec, 0, NULL);
    5900                 :      72535 :             if (value != 0)
    5901                 :          0 :               return value;
    5902                 :            :             break;
    5903                 :            : 
    5904                 :      72727 :           case 'l':
    5905                 :      72727 :             value = do_spec_1 (link_spec, 0, NULL);
    5906                 :      72727 :             if (value != 0)
    5907                 :          0 :               return value;
    5908                 :            :             break;
    5909                 :            : 
    5910                 :     140666 :           case 'L':
    5911                 :     140666 :             value = do_spec_1 (lib_spec, 0, NULL);
    5912                 :     140666 :             if (value != 0)
    5913                 :          0 :               return value;
    5914                 :            :             break;
    5915                 :            : 
    5916                 :          0 :           case 'M':
    5917                 :          0 :             if (multilib_os_dir == NULL)
    5918                 :          0 :               obstack_1grow (&obstack, '.');
    5919                 :            :             else
    5920                 :          0 :               obstack_grow (&obstack, multilib_os_dir,
    5921                 :            :                             strlen (multilib_os_dir));
    5922                 :            :             break;
    5923                 :            : 
    5924                 :     281160 :           case 'G':
    5925                 :     281160 :             value = do_spec_1 (libgcc_spec, 0, NULL);
    5926                 :     281160 :             if (value != 0)
    5927                 :          0 :               return value;
    5928                 :            :             break;
    5929                 :            : 
    5930                 :          0 :           case 'R':
    5931                 :            :             /* We assume there is a directory
    5932                 :            :                separator at the end of this string.  */
    5933                 :          0 :             if (target_system_root)
    5934                 :            :               {
    5935                 :          0 :                 obstack_grow (&obstack, target_system_root,
    5936                 :            :                               strlen (target_system_root));
    5937                 :          0 :                 if (target_sysroot_suffix)
    5938                 :          0 :                   obstack_grow (&obstack, target_sysroot_suffix,
    5939                 :            :                                 strlen (target_sysroot_suffix));
    5940                 :            :               }
    5941                 :            :             break;
    5942                 :            : 
    5943                 :      72535 :           case 'S':
    5944                 :      72535 :             value = do_spec_1 (startfile_spec, 0, NULL);
    5945                 :      72535 :             if (value != 0)
    5946                 :          0 :               return value;
    5947                 :            :             break;
    5948                 :            : 
    5949                 :            :             /* Here we define characters other than letters and digits.  */
    5950                 :            : 
    5951                 :   29412200 :           case '{':
    5952                 :   29412200 :             p = handle_braces (p);
    5953                 :   29412200 :             if (p == 0)
    5954                 :            :               return -1;
    5955                 :            :             break;
    5956                 :            : 
    5957                 :     118759 :           case ':':
    5958                 :     118759 :             p = handle_spec_function (p, NULL, soft_matched_part);
    5959                 :     118759 :             if (p == 0)
    5960                 :            :               return -1;
    5961                 :            :             break;
    5962                 :            : 
    5963                 :          0 :           case '%':
    5964                 :          0 :             obstack_1grow (&obstack, '%');
    5965                 :          0 :             break;
    5966                 :            : 
    5967                 :            :           case '.':
    5968                 :            :             {
    5969                 :            :               unsigned len = 0;
    5970                 :            : 
    5971                 :       9690 :               while (p[len] && p[len] != ' ' && p[len] != '%')
    5972                 :       4845 :                 len++;
    5973                 :       4845 :               suffix_subst = save_string (p - 1, len + 1);
    5974                 :       4845 :               p += len;
    5975                 :            :             }
    5976                 :       4845 :            break;
    5977                 :            : 
    5978                 :            :            /* Henceforth ignore the option(s) matching the pattern
    5979                 :            :               after the %<.  */
    5980                 :     218553 :           case '<':
    5981                 :     218553 :           case '>':
    5982                 :     218553 :             {
    5983                 :     218553 :               unsigned len = 0;
    5984                 :     218553 :               int have_wildcard = 0;
    5985                 :     218553 :               int i;
    5986                 :     218553 :               int switch_option;
    5987                 :            : 
    5988                 :     218553 :               if (c == '>')
    5989                 :     218553 :                 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
    5990                 :            :               else
    5991                 :     218551 :                 switch_option = SWITCH_IGNORE;
    5992                 :            : 
    5993                 :    3825000 :               while (p[len] && p[len] != ' ' && p[len] != '\t')
    5994                 :    3606450 :                 len++;
    5995                 :            : 
    5996                 :     218553 :               if (p[len-1] == '*')
    5997                 :      11830 :                 have_wildcard = 1;
    5998                 :            : 
    5999                 :    4231570 :               for (i = 0; i < n_switches; i++)
    6000                 :    4013020 :                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
    6001                 :        805 :                     && (have_wildcard || switches[i].part1[len] == '\0'))
    6002                 :            :                   {
    6003                 :        805 :                     switches[i].live_cond |= switch_option;
    6004                 :            :                     /* User switch be validated from validate_all_switches.
    6005                 :            :                        when the definition is seen from the spec file.
    6006                 :            :                        If not defined anywhere, will be rejected.  */
    6007                 :        805 :                     if (switches[i].known)
    6008                 :        805 :                       switches[i].validated = true;
    6009                 :            :                   }
    6010                 :            : 
    6011                 :            :               p += len;
    6012                 :            :             }
    6013                 :            :             break;
    6014                 :            : 
    6015                 :     124156 :           case '*':
    6016                 :     124156 :             if (soft_matched_part)
    6017                 :            :               {
    6018                 :     124156 :                 if (soft_matched_part[0])
    6019                 :        316 :                   do_spec_1 (soft_matched_part, 1, NULL);
    6020                 :            :                 /* Only insert a space after the substitution if it is at the
    6021                 :            :                    end of the current sequence.  So if:
    6022                 :            : 
    6023                 :            :                      "%{foo=*:bar%*}%{foo=*:one%*two}"
    6024                 :            : 
    6025                 :            :                    matches -foo=hello then it will produce:
    6026                 :            :                    
    6027                 :            :                      barhello onehellotwo
    6028                 :            :                 */
    6029                 :     124156 :                 if (*p == 0 || *p == '}')
    6030                 :     124156 :                   do_spec_1 (" ", 0, NULL);
    6031                 :            :               }
    6032                 :            :             else
    6033                 :            :               /* Catch the case where a spec string contains something like
    6034                 :            :                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
    6035                 :            :                  hand side of the :.  */
    6036                 :          0 :               error ("spec failure: %<%%*%> has not been initialized by pattern match");
    6037                 :            :             break;
    6038                 :            : 
    6039                 :            :             /* Process a string found as the value of a spec given by name.
    6040                 :            :                This feature allows individual machine descriptions
    6041                 :            :                to add and use their own specs.  */
    6042                 :            :           case '(':
    6043                 :            :             {
    6044                 :   19954400 :               const char *name = p;
    6045                 :   19954400 :               struct spec_list *sl;
    6046                 :   19954400 :               int len;
    6047                 :            : 
    6048                 :            :               /* The string after the S/P is the name of a spec that is to be
    6049                 :            :                  processed.  */
    6050                 :   19954400 :               while (*p && *p != ')')
    6051                 :   18212500 :                 p++;
    6052                 :            : 
    6053                 :            :               /* See if it's in the list.  */
    6054                 :   29941800 :               for (len = p - name, sl = specs; sl; sl = sl->next)
    6055                 :   29796300 :                 if (sl->name_len == len && !strncmp (sl->name, name, len))
    6056                 :            :                   {
    6057                 :    1596460 :                     name = *(sl->ptr_spec);
    6058                 :            : #ifdef DEBUG_SPECS
    6059                 :            :                     fnotice (stderr, "Processing spec (%s), which is '%s'\n",
    6060                 :            :                              sl->name, name);
    6061                 :            : #endif
    6062                 :    1596460 :                     break;
    6063                 :            :                   }
    6064                 :            : 
    6065                 :    1741920 :               if (sl)
    6066                 :            :                 {
    6067                 :    1596460 :                   value = do_spec_1 (name, 0, NULL);
    6068                 :    1596460 :                   if (value != 0)
    6069                 :       4000 :                     return value;
    6070                 :            :                 }
    6071                 :            : 
    6072                 :            :               /* Discard the closing paren.  */
    6073                 :    1737920 :               if (*p)
    6074                 :    1737920 :                 p++;
    6075                 :            :             }
    6076                 :            :             break;
    6077                 :            : 
    6078                 :          0 :           default:
    6079                 :          0 :             error ("spec failure: unrecognized spec option %qc", c);
    6080                 :          0 :             break;
    6081                 :            :           }
    6082                 :            :         break;
    6083                 :            : 
    6084                 :          0 :       case '\\':
    6085                 :            :         /* Backslash: treat next character as ordinary.  */
    6086                 :          0 :         c = *p++;
    6087                 :            : 
    6088                 :            :         /* Fall through.  */
    6089                 :  253440000 :       default:
    6090                 :            :         /* Ordinary character: put it into the current argument.  */
    6091                 :  253440000 :         obstack_1grow (&obstack, c);
    6092                 :  253440000 :         arg_going = 1;
    6093                 :            :       }
    6094                 :            : 
    6095                 :            :   /* End of string.  If we are processing a spec function, we need to
    6096                 :            :      end any pending argument.  */
    6097                 :   34118900 :   if (processing_spec_function)
    6098                 :    2446500 :     end_going_arg ();
    6099                 :            : 
    6100                 :            :   return 0;
    6101                 :            : }
    6102                 :            : 
    6103                 :            : /* Look up a spec function.  */
    6104                 :            : 
    6105                 :            : static const struct spec_function *
    6106                 :     903995 : lookup_spec_function (const char *name)
    6107                 :            : {
    6108                 :     903995 :   const struct spec_function *sf;
    6109                 :            : 
    6110                 :    8474130 :   for (sf = static_spec_functions; sf->name != NULL; sf++)
    6111                 :    8474130 :     if (strcmp (sf->name, name) == 0)
    6112                 :          0 :       return sf;
    6113                 :            : 
    6114                 :            :   return NULL;
    6115                 :            : }
    6116                 :            : 
    6117                 :            : /* Evaluate a spec function.  */
    6118                 :            : 
    6119                 :            : static const char *
    6120                 :     903995 : eval_spec_function (const char *func, const char *args,
    6121                 :            :                     const char *soft_matched_part)
    6122                 :            : {
    6123                 :     903995 :   const struct spec_function *sf;
    6124                 :     903995 :   const char *funcval;
    6125                 :            : 
    6126                 :            :   /* Saved spec processing context.  */
    6127                 :     903995 :   vec<const_char_p> save_argbuf;
    6128                 :            : 
    6129                 :     903995 :   int save_arg_going;
    6130                 :     903995 :   int save_delete_this_arg;
    6131                 :     903995 :   int save_this_is_output_file;
    6132                 :     903995 :   int save_this_is_library_file;
    6133                 :     903995 :   int save_input_from_pipe;
    6134                 :     903995 :   int save_this_is_linker_script;
    6135                 :     903995 :   const char *save_suffix_subst;
    6136                 :            : 
    6137                 :     903995 :   int save_growing_size;
    6138                 :     903995 :   void *save_growing_value = NULL;
    6139                 :            : 
    6140                 :     903995 :   sf = lookup_spec_function (func);
    6141                 :     903995 :   if (sf == NULL)
    6142                 :          0 :     fatal_error (input_location, "unknown spec function %qs", func);
    6143                 :            : 
    6144                 :            :   /* Push the spec processing context.  */
    6145                 :     903995 :   save_argbuf = argbuf;
    6146                 :            : 
    6147                 :     903995 :   save_arg_going = arg_going;
    6148                 :     903995 :   save_delete_this_arg = delete_this_arg;
    6149                 :     903995 :   save_this_is_output_file = this_is_output_file;
    6150                 :     903995 :   save_this_is_library_file = this_is_library_file;
    6151                 :     903995 :   save_this_is_linker_script = this_is_linker_script;
    6152                 :     903995 :   save_input_from_pipe = input_from_pipe;
    6153                 :     903995 :   save_suffix_subst = suffix_subst;
    6154                 :            : 
    6155                 :            :   /* If we have some object growing now, finalize it so the args and function
    6156                 :            :      eval proceed from a cleared context.  This is needed to prevent the first
    6157                 :            :      constructed arg from mistakenly including the growing value.  We'll push
    6158                 :            :      this value back on the obstack once the function evaluation is done, to
    6159                 :            :      restore a consistent processing context for our caller.  This is fine as
    6160                 :            :      the address of growing objects isn't guaranteed to remain stable until
    6161                 :            :      they are finalized, and we expect this situation to be rare enough for
    6162                 :            :      the extra copy not to be an issue.  */
    6163                 :     903995 :   save_growing_size = obstack_object_size (&obstack);
    6164                 :     903995 :   if (save_growing_size > 0)
    6165                 :          0 :     save_growing_value = obstack_finish (&obstack);
    6166                 :            : 
    6167                 :            :   /* Create a new spec processing context, and build the function
    6168                 :            :      arguments.  */
    6169                 :            : 
    6170                 :     903995 :   alloc_args ();
    6171                 :     903995 :   if (do_spec_2 (args, soft_matched_part) < 0)
    6172                 :          0 :     fatal_error (input_location, "error in arguments to spec function %qs",
    6173                 :            :                  func);
    6174                 :            : 
    6175                 :            :   /* argbuf_index is an index for the next argument to be inserted, and
    6176                 :            :      so contains the count of the args already inserted.  */
    6177                 :            : 
    6178                 :    2711980 :   funcval = (*sf->func) (argbuf.length (),
    6179                 :            :                          argbuf.address ());
    6180                 :            : 
    6181                 :            :   /* Pop the spec processing context.  */
    6182                 :     903995 :   argbuf.release ();
    6183                 :     903995 :   argbuf = save_argbuf;
    6184                 :            : 
    6185                 :     903995 :   arg_going = save_arg_going;
    6186                 :     903995 :   delete_this_arg = save_delete_this_arg;
    6187                 :     903995 :   this_is_output_file = save_this_is_output_file;
    6188                 :     903995 :   this_is_library_file = save_this_is_library_file;
    6189                 :     903995 :   this_is_linker_script = save_this_is_linker_script;
    6190                 :     903995 :   input_from_pipe = save_input_from_pipe;
    6191                 :     903995 :   suffix_subst = save_suffix_subst;
    6192                 :            : 
    6193                 :     903995 :   if (save_growing_size > 0)
    6194                 :          0 :     obstack_grow (&obstack, save_growing_value, save_growing_size);
    6195                 :            : 
    6196                 :     903995 :   return funcval;
    6197                 :            : }
    6198                 :            : 
    6199                 :            : /* Handle a spec function call of the form:
    6200                 :            : 
    6201                 :            :    %:function(args)
    6202                 :            : 
    6203                 :            :    ARGS is processed as a spec in a separate context and split into an
    6204                 :            :    argument vector in the normal fashion.  The function returns a string
    6205                 :            :    containing a spec which we then process in the caller's context, or
    6206                 :            :    NULL if no processing is required.
    6207                 :            : 
    6208                 :            :    If RETVAL_NONNULL is not NULL, then store a bool whether function
    6209                 :            :    returned non-NULL.
    6210                 :            : 
    6211                 :            :    SOFT_MATCHED_PART holds the current value of a matched * pattern, which
    6212                 :            :    may be re-expanded with a %* as part of the function arguments.  */
    6213                 :            : 
    6214                 :            : static const char *
    6215                 :     903995 : handle_spec_function (const char *p, bool *retval_nonnull,
    6216                 :            :                       const char *soft_matched_part)
    6217                 :            : {
    6218                 :     903995 :   char *func, *args;
    6219                 :     903995 :   const char *endp, *funcval;
    6220                 :     903995 :   int count;
    6221                 :            : 
    6222                 :     903995 :   processing_spec_function++;
    6223                 :            : 
    6224                 :            :   /* Get the function name.  */
    6225                 :    7524280 :   for (endp = p; *endp != '\0'; endp++)
    6226                 :            :     {
    6227                 :    7524280 :       if (*endp == '(')         /* ) */
    6228                 :            :         break;
    6229                 :            :       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
    6230                 :    6620280 :       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
    6231                 :          0 :         fatal_error (input_location, "malformed spec function name");
    6232                 :            :     }
    6233                 :     903995 :   if (*endp != '(')             /* ) */
    6234                 :          0 :     fatal_error (input_location, "no arguments for spec function");
    6235                 :     903995 :   func = save_string (p, endp - p);
    6236                 :     903995 :   p = ++endp;
    6237                 :            : 
    6238                 :            :   /* Get the arguments.  */
    6239                 :   16150500 :   for (count = 0; *endp != '\0'; endp++)
    6240                 :            :     {
    6241                 :            :       /* ( */
    6242                 :   16150500 :       if (*endp == ')')
    6243                 :            :         {
    6244                 :     972128 :           if (count == 0)
    6245                 :            :             break;
    6246                 :      68133 :           count--;
    6247                 :            :         }
    6248                 :   15178300 :       else if (*endp == '(')    /* ) */
    6249                 :      68133 :         count++;
    6250                 :            :     }
    6251                 :            :   /* ( */
    6252                 :     903995 :   if (*endp != ')')
    6253                 :          0 :     fatal_error (input_location, "malformed spec function arguments");
    6254                 :     903995 :   args = save_string (p, endp - p);
    6255                 :     903995 :   p = ++endp;
    6256                 :            : 
    6257                 :            :   /* p now points to just past the end of the spec function expression.  */
    6258                 :            : 
    6259                 :     903995 :   funcval = eval_spec_function (func, args, soft_matched_part);
    6260                 :     903995 :   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
    6261                 :            :     p = NULL;
    6262                 :     903995 :   if (retval_nonnull)
    6263                 :     785236 :     *retval_nonnull = funcval != NULL;
    6264                 :            : 
    6265                 :     903995 :   free (func);
    6266                 :     903995 :   free (args);
    6267                 :            : 
    6268                 :     903995 :   processing_spec_function--;
    6269                 :            : 
    6270                 :     903995 :   return p;
    6271                 :            : }
    6272                 :            : 
    6273                 :            : /* Inline subroutine of handle_braces.  Returns true if the current
    6274                 :            :    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
    6275                 :            : static inline bool
    6276                 :          0 : input_suffix_matches (const char *atom, const char *end_atom)
    6277                 :            : {
    6278                 :          0 :   return (input_suffix
    6279                 :          0 :           && !strncmp (input_suffix, atom, end_atom - atom)
    6280                 :          0 :           && input_suffix[end_atom - atom] == '\0');
    6281                 :            : }
    6282                 :            : 
    6283                 :            : /* Subroutine of handle_braces.  Returns true if the current
    6284                 :            :    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
    6285                 :            : static bool
    6286                 :          0 : input_spec_matches (const char *atom, const char *end_atom)
    6287                 :            : {
    6288                 :          0 :   return (input_file_compiler
    6289                 :          0 :           && input_file_compiler->suffix
    6290                 :          0 :           && input_file_compiler->suffix[0] != '\0'
    6291                 :          0 :           && !strncmp (input_file_compiler->suffix + 1, atom,
    6292                 :          0 :                        end_atom - atom)
    6293                 :          0 :           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
    6294                 :            : }
    6295                 :            : 
    6296                 :            : /* Subroutine of handle_braces.  Returns true if a switch
    6297                 :            :    matching the atom bracketed by ATOM and END_ATOM appeared on the
    6298                 :            :    command line.  */
    6299                 :            : static bool
    6300                 :   29383700 : switch_matches (const char *atom, const char *end_atom, int starred)
    6301                 :            : {
    6302                 :   29383700 :   int i;
    6303                 :   29383700 :   int len = end_atom - atom;
    6304                 :   29383700 :   int plen = starred ? len : -1;
    6305                 :            : 
    6306                 :  566105000 :   for (i = 0; i < n_switches; i++)
    6307                 :  538215000 :     if (!strncmp (switches[i].part1, atom, len)
    6308                 :    2216430 :         && (starred || switches[i].part1[len] == '\0')
    6309                 :  539710000 :         && check_live_switch (i, plen))
    6310                 :            :       return true;
    6311                 :            : 
    6312                 :            :     /* Check if a switch with separated form matching the atom.
    6313                 :            :        We check -D and -U switches. */
    6314                 :  536721000 :     else if (switches[i].args != 0)
    6315                 :            :       {
    6316                 :  170681000 :         if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
    6317                 :    6353540 :             && *switches[i].part1 == atom[0])
    6318                 :            :           {
    6319                 :          1 :             if (!strncmp (switches[i].args[0], &atom[1], len - 1)
    6320                 :          1 :                 && (starred || (switches[i].part1[1] == '\0'
    6321                 :          1 :                                 && switches[i].args[0][len - 1] == '\0'))
    6322                 :          3 :                 && check_live_switch (i, (starred ? 1 : -1)))
    6323                 :            :               return true;
    6324                 :            :           }
    6325                 :            :       }
    6326                 :            : 
    6327                 :            :   return false;
    6328                 :            : }
    6329                 :            : 
    6330                 :            : /* Inline subroutine of handle_braces.  Mark all of the switches which
    6331                 :            :    match ATOM (extends to END_ATOM; STARRED indicates whether there
    6332                 :            :    was a star after the atom) for later processing.  */
    6333                 :            : static inline void
    6334                 :    7700340 : mark_matching_switches (const char *atom, const char *end_atom, int starred)
    6335                 :            : {
    6336                 :    7700340 :   int i;
    6337                 :    7700340 :   int len = end_atom - atom;
    6338                 :    7700340 :   int plen = starred ? len : -1;
    6339                 :            : 
    6340                 :  150355000 :   for (i = 0; i < n_switches; i++)
    6341                 :  142655000 :     if (!strncmp (switches[i].part1, atom, len)
    6342                 :    3447050 :         && (starred || switches[i].part1[len] == '\0')
    6343                 :  145936000 :         && check_live_switch (i, plen))
    6344                 :    3280560 :       switches[i].ordering = 1;
    6345                 :    7700340 : }
    6346                 :            : 
    6347                 :            : /* Inline subroutine of handle_braces.  Process all the currently
    6348                 :            :    marked switches through give_switch, and clear the marks.  */
    6349                 :            : static inline void
    6350                 :    6626460 : process_marked_switches (void)
    6351                 :            : {
    6352                 :    6626460 :   int i;
    6353                 :            : 
    6354                 :  129392000 :   for (i = 0; i < n_switches; i++)
    6355                 :  122766000 :     if (switches[i].ordering == 1)
    6356                 :            :       {
    6357                 :    3280560 :         switches[i].ordering = 0;
    6358                 :    3280560 :         give_switch (i, 0);
    6359                 :            :       }
    6360                 :    6626460 : }
    6361                 :            : 
    6362                 :            : /* Handle a %{ ... } construct.  P points just inside the leading {.
    6363                 :            :    Returns a pointer one past the end of the brace block, or 0
    6364                 :            :    if we call do_spec_1 and that returns -1.  */
    6365                 :            : 
    6366                 :            : static const char *
    6367                 :   29761500 : handle_braces (const char *p)
    6368                 :            : {
    6369                 :   29761500 :   const char *atom, *end_atom;
    6370                 :   29761500 :   const char *d_atom = NULL, *d_end_atom = NULL;
    6371                 :   29761500 :   char *esc_buf = NULL, *d_esc_buf = NULL;
    6372                 :   29761500 :   int esc;
    6373                 :   29761500 :   const char *orig = p;
    6374                 :            : 
    6375                 :   29761500 :   bool a_is_suffix;
    6376                 :   29761500 :   bool a_is_spectype;
    6377                 :   29761500 :   bool a_is_starred;
    6378                 :   29761500 :   bool a_is_negated;
    6379                 :   29761500 :   bool a_matched;
    6380                 :            : 
    6381                 :   29761500 :   bool a_must_be_last = false;
    6382                 :   29761500 :   bool ordered_set    = false;
    6383                 :   29761500 :   bool disjunct_set   = false;
    6384                 :   29761500 :   bool disj_matched   = false;
    6385                 :   29761500 :   bool disj_starred   = true;
    6386                 :   29761500 :   bool n_way_choice   = false;
    6387                 :   29761500 :   bool n_way_matched  = false;
    6388                 :            : 
    6389                 :            : #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
    6390                 :            : 
    6391                 :   39804000 :   do
    6392                 :            :     {
    6393                 :   39804000 :       if (a_must_be_last)
    6394                 :          0 :         goto invalid;
    6395                 :            : 
    6396                 :            :       /* Scan one "atom" (S in the description above of %{}, possibly
    6397                 :            :          with '!', '.', '@', ',', or '*' modifiers).  */
    6398                 :   39804000 :       a_matched = false;
    6399                 :   39804000 :       a_is_suffix = false;
    6400                 :   39804000 :       a_is_starred = false;
    6401                 :   39804000 :       a_is_negated = false;
    6402                 :   39804000 :       a_is_spectype = false;
    6403                 :            : 
    6404                 :   45460700 :       SKIP_WHITE ();
    6405                 :   39804000 :       if (*p == '!')
    6406                 :   10412400 :         p++, a_is_negated = true;
    6407                 :            : 
    6408                 :   39804000 :       SKIP_WHITE ();
    6409                 :   39804000 :       if (*p == '%' && p[1] == ':')
    6410                 :            :         {
    6411                 :     785236 :           atom = NULL;
    6412                 :     785236 :           end_atom = NULL;
    6413                 :     785236 :           p = handle_spec_function (p + 2, &a_matched, NULL);
    6414                 :            :         }
    6415                 :            :       else
    6416                 :            :         {
    6417                 :   39018700 :           if (*p == '.')
    6418                 :          0 :             p++, a_is_suffix = true;
    6419                 :   39018700 :           else if (*p == ',')
    6420                 :          0 :             p++, a_is_spectype = true;
    6421                 :            : 
    6422                 :   39018700 :           atom = p;
    6423                 :   39018700 :           esc = 0;
    6424                 :   55797900 :           while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
    6425                 :  324530000 :                  || *p == ',' || *p == '.' || *p == '@' || *p == '\\')
    6426                 :            :             {
    6427                 :  246492000 :               if (*p == '\\')
    6428                 :            :                 {
    6429                 :          0 :                   p++;
    6430                 :          0 :                   if (!*p)
    6431                 :          0 :                     fatal_error (input_location,
    6432                 :            :                                  "braced spec %qs ends in escape", orig);
    6433                 :          0 :                   esc++;
    6434                 :            :                 }
    6435                 :  246492000 :               p++;
    6436                 :            :             }
    6437                 :   39018700 :           end_atom = p;
    6438                 :            : 
    6439                 :   39018700 :           if (esc)
    6440                 :            :             {
    6441                 :          0 :               const char *ap;
    6442                 :          0 :               char *ep;
    6443                 :            : 
    6444                 :          0 :               if (esc_buf && esc_buf != d_esc_buf)
    6445                 :          0 :                 free (esc_buf);
    6446                 :          0 :               esc_buf = NULL;
    6447                 :          0 :               ep = esc_buf = (char *) xmalloc (end_atom - atom - esc + 1);
    6448                 :          0 :               for (ap = atom; ap != end_atom; ap++, ep++)
    6449                 :            :                 {
    6450                 :          0 :                   if (*ap == '\\')
    6451                 :          0 :                     ap++;
    6452                 :          0 :                   *ep = *ap;
    6453                 :            :                 }
    6454                 :          0 :               *ep = '\0';
    6455                 :          0 :               atom = esc_buf;
    6456                 :          0 :               end_atom = ep;
    6457                 :            :             }
    6458                 :            : 
    6459                 :   39018700 :           if (*p == '*')
    6460                 :    8158560 :             p++, a_is_starred = 1;
    6461                 :            :         }
    6462                 :            : 
    6463                 :   39804000 :       SKIP_WHITE ();
    6464                 :   39804000 :       switch (*p)
    6465                 :            :         {
    6466                 :    7700340 :         case '&': case '}':
    6467                 :            :           /* Substitute the switch(es) indicated by the current atom.  */
    6468                 :    7700340 :           ordered_set = true;
    6469                 :    7700340 :           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
    6470                 :    7700340 :               || a_is_spectype || atom == end_atom)
    6471                 :          0 :             goto invalid;
    6472                 :            : 
    6473                 :    7700340 :           mark_matching_switches (atom, end_atom, a_is_starred);
    6474                 :            : 
    6475                 :    7700340 :           if (*p == '}')
    6476                 :    6626460 :             process_marked_switches ();
    6477                 :            :           break;
    6478                 :            : 
    6479                 :   32103600 :         case '|': case ':':
    6480                 :            :           /* Substitute some text if the current atom appears as a switch
    6481                 :            :              or suffix.  */
    6482                 :   32103600 :           disjunct_set = true;
    6483                 :   32103600 :           if (ordered_set)
    6484                 :          0 :             goto invalid;
    6485                 :            : 
    6486                 :   32103600 :           if (atom && atom == end_atom)
    6487                 :            :             {
    6488                 :    1278030 :               if (!n_way_choice || disj_matched || *p == '|'
    6489                 :    1278030 :                   || a_is_negated || a_is_suffix || a_is_spectype
    6490                 :    1278030 :                   || a_is_starred)
    6491                 :          0 :                 goto invalid;
    6492                 :            : 
    6493                 :            :               /* An empty term may appear as the last choice of an
    6494                 :            :                  N-way choice set; it means "otherwise".  */
    6495                 :    1278030 :               a_must_be_last = true;
    6496                 :    1278030 :               disj_matched = !n_way_matched;
    6497                 :    1278030 :               disj_starred = false;
    6498                 :            :             }
    6499                 :            :           else
    6500                 :            :             {
    6501                 :   30825600 :               if ((a_is_suffix || a_is_spectype) && a_is_starred)
    6502                 :          0 :                 goto invalid;
    6503                 :            : 
    6504                 :   30825600 :               if (!a_is_starred)
    6505                 :   27018000 :                 disj_starred = false;
    6506                 :            : 
    6507                 :            :               /* Don't bother testing this atom if we already have a
    6508                 :            :                  match.  */
    6509                 :   30825600 :               if (!disj_matched && !n_way_matched)
    6510                 :            :                 {
    6511                 :   30084700 :                   if (atom == NULL)
    6512                 :            :                     /* a_matched is already set by handle_spec_function.  */;
    6513                 :   29311000 :                   else if (a_is_suffix)
    6514                 :          0 :                     a_matched = input_suffix_matches (atom, end_atom);
    6515                 :   29311000 :                   else if (a_is_spectype)
    6516                 :          0 :                     a_matched = input_spec_matches (atom, end_atom);
    6517                 :            :                   else
    6518                 :   29311000 :                     a_matched = switch_matches (atom, end_atom, a_is_starred);
    6519                 :            : 
    6520                 :   30084700 :                   if (a_matched != a_is_negated)
    6521                 :            :                     {
    6522                 :   10241700 :                       disj_matched = true;
    6523                 :   10241700 :                       d_atom = atom;
    6524                 :   10241700 :                       d_end_atom = end_atom;
    6525                 :   10241700 :                       d_esc_buf = esc_buf;
    6526                 :            :                     }
    6527                 :            :                 }
    6528                 :            :             }
    6529                 :            : 
    6530                 :   32103600 :           if (*p == ':')
    6531                 :            :             {
    6532                 :            :               /* Found the body, that is, the text to substitute if the
    6533                 :            :                  current disjunction matches.  */
    6534                 :   50421900 :               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
    6535                 :   25211000 :                                       disj_matched && !n_way_matched);
    6536                 :   25211000 :               if (p == 0)
    6537                 :      24753 :                 goto done;
    6538                 :            : 
    6539                 :            :               /* If we have an N-way choice, reset state for the next
    6540                 :            :                  disjunction.  */
    6541                 :   25186200 :               if (*p == ';')
    6542                 :            :                 {
    6543                 :    2075940 :                   n_way_choice = true;
    6544                 :    2075940 :                   n_way_matched |= disj_matched;
    6545                 :    2075940 :                   disj_matched = false;
    6546                 :    2075940 :                   disj_starred = true;
    6547                 :    2075940 :                   d_atom = d_end_atom = NULL;
    6548                 :            :                 }
    6549                 :            :             }
    6550                 :            :           break;
    6551                 :            : 
    6552                 :          0 :         default:
    6553                 :          0 :           goto invalid;
    6554                 :            :         }
    6555                 :            :     }
    6556                 :   39779200 :   while (*p++ != '}');
    6557                 :            : 
    6558                 :   29736700 :  done:
    6559                 :   29761500 :   if (d_esc_buf && d_esc_buf != esc_buf)
    6560                 :          0 :     free (d_esc_buf);
    6561                 :   29761500 :   if (esc_buf)
    6562                 :          0 :     free (esc_buf);
    6563                 :            : 
    6564                 :   29761500 :   return p;
    6565                 :            : 
    6566                 :          0 :  invalid:
    6567                 :          0 :   fatal_error (input_location, "braced spec %qs is invalid at %qc", orig, *p);
    6568                 :            : 
    6569                 :            : #undef SKIP_WHITE
    6570                 :            : }
    6571                 :            : 
    6572                 :            : /* Subroutine of handle_braces.  Scan and process a brace substitution body
    6573                 :            :    (X in the description of %{} syntax).  P points one past the colon;
    6574                 :            :    ATOM and END_ATOM bracket the first atom which was found to be true
    6575                 :            :    (present) in the current disjunction; STARRED indicates whether all
    6576                 :            :    the atoms in the current disjunction were starred (for syntax validation);
    6577                 :            :    MATCHED indicates whether the disjunction matched or not, and therefore
    6578                 :            :    whether or not the body is to be processed through do_spec_1 or just
    6579                 :            :    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
    6580                 :            :    returns -1.  */
    6581                 :            : 
    6582                 :            : static const char *
    6583                 :   25211000 : process_brace_body (const char *p, const char *atom, const char *end_atom,
    6584                 :            :                     int starred, int matched)
    6585                 :            : {
    6586                 :   25211000 :   const char *body, *end_body;
    6587                 :   25211000 :   unsigned int nesting_level;
    6588                 :   25211000 :   bool have_subst     = false;
    6589                 :            : 
    6590                 :            :   /* Locate the closing } or ;, honoring nested braces.
    6591                 :            :      Trim trailing whitespace.  */
    6592                 :   25211000 :   body = p;
    6593                 :   25211000 :   nesting_level = 1;
    6594                 : 7426510000 :   for (;;)
    6595                 :            :     {
    6596                 : 3725860000 :       if (*p == '{')
    6597                 :  111611000 :         nesting_level++;
    6598                 : 3614250000 :       else if (*p == '}')
    6599                 :            :         {
    6600                 :  134746000 :           if (!--nesting_level)
    6601                 :            :             break;
    6602                 :            :         }
    6603                 : 3479500000 :       else if (*p == ';' && nesting_level == 1)
    6604                 :            :         break;
    6605                 : 3477430000 :       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
    6606                 :            :         have_subst = true;
    6607                 : 3476750000 :       else if (*p == '\0')
    6608                 :          0 :         goto invalid;
    6609                 : 3700650000 :       p++;
    6610                 :            :     }
    6611                 :            : 
    6612                 :            :   end_body = p;
    6613                 :   27003300 :   while (end_body[-1] == ' ' || end_body[-1] == '\t')
    6614                 :    1792360 :     end_body--;
    6615                 :            : 
    6616                 :   25211000 :   if (have_subst && !starred)
    6617                 :          0 :     goto invalid;
    6618                 :            : 
    6619                 :   25211000 :   if (matched)
    6620                 :            :     {
    6621                 :            :       /* Copy the substitution body to permanent storage and execute it.
    6622                 :            :          If have_subst is false, this is a simple matter of running the
    6623                 :            :          body through do_spec_1...  */
    6624                 :   10949500 :       char *string = save_string (body, end_body - body);
    6625                 :   10949500 :       if (!have_subst)
    6626                 :            :         {
    6627                 :   10825300 :           if (do_spec_1 (string, 0, NULL) < 0)
    6628                 :            :             {
    6629                 :      24753 :               free (string);
    6630                 :      24753 :               return 0;
    6631                 :            :             }
    6632                 :            :         }
    6633                 :            :       else
    6634                 :            :         {
    6635                 :            :           /* ... but if have_subst is true, we have to process the
    6636                 :            :              body once for each matching switch, with %* set to the
    6637                 :            :              variant part of the switch.  */
    6638                 :     124152 :           unsigned int hard_match_len = end_atom - atom;
    6639                 :     124152 :           int i;
    6640                 :            : 
    6641                 :    2538830 :           for (i = 0; i < n_switches; i++)
    6642                 :    2414680 :             if (!strncmp (switches[i].part1, atom, hard_match_len)
    6643                 :    2414680 :                 && check_live_switch (i, hard_match_len))
    6644                 :            :               {
    6645                 :     124156 :                 if (do_spec_1 (string, 0,
    6646                 :     124156 :                                &switches[i].part1[hard_match_len]) < 0)
    6647                 :            :                   {
    6648                 :          0 :                     free (string);
    6649                 :          0 :                     return 0;
    6650                 :            :                   }
    6651                 :            :                 /* Pass any arguments this switch has.  */
    6652                 :     124156 :                 give_switch (i, 1);
    6653                 :     124156 :                 suffix_subst = NULL;
    6654                 :            :               }
    6655                 :            :         }
    6656                 :   10924700 :       free (string);
    6657                 :            :     }
    6658                 :            : 
    6659                 :            :   return p;
    6660                 :            : 
    6661                 :          0 :  invalid:
    6662                 :          0 :   fatal_error (input_location, "braced spec body %qs is invalid", body);
    6663                 :            : }
    6664                 :            : 
    6665                 :            : /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
    6666                 :            :    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
    6667                 :            :    spec, or -1 if either exact match or %* is used.
    6668                 :            : 
    6669                 :            :    A -O switch is obsoleted by a later -O switch.  A -f, -g, -m, or -W switch
    6670                 :            :    whose value does not begin with "no-" is obsoleted by the same value
    6671                 :            :    with the "no-", similarly for a switch with the "no-" prefix.  */
    6672                 :            : 
    6673                 :            : static int
    6674                 :    4900520 : check_live_switch (int switchnum, int prefix_length)
    6675                 :            : {
    6676                 :    4900520 :   const char *name = switches[switchnum].part1;
    6677                 :    4900520 :   int i;
    6678                 :            : 
    6679                 :            :   /* If we already processed this switch and determined if it was
    6680                 :            :      live or not, return our past determination.  */
    6681                 :    4900520 :   if (switches[switchnum].live_cond != 0)
    6682                 :     969631 :     return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
    6683                 :            :             && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
    6684                 :     969631 :             && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
    6685                 :     969631 :                == 0);
    6686                 :            : 
    6687                 :            :   /* In the common case of {<at-most-one-letter>*}, a negating
    6688                 :            :      switch would always match, so ignore that case.  We will just
    6689                 :            :      send the conflicting switches to the compiler phase.  */
    6690                 :    3930890 :   if (prefix_length >= 0 && prefix_length <= 1)
    6691                 :            :     return 1;
    6692                 :            : 
    6693                 :            :   /* Now search for duplicate in a manner that depends on the name.  */
    6694                 :     525075 :   switch (*name)
    6695                 :            :     {
    6696                 :         41 :     case 'O':
    6697                 :        351 :       for (i = switchnum + 1; i < n_switches; i++)
    6698                 :        314 :         if (switches[i].part1[0] == 'O')
    6699                 :            :           {
    6700                 :          4 :             switches[switchnum].validated = true;
    6701                 :          4 :             switches[switchnum].live_cond = SWITCH_FALSE;
    6702                 :          4 :             return 0;
    6703                 :            :           }
    6704                 :            :       break;
    6705                 :            : 
    6706                 :      67056 :     case 'W':  case 'f':  case 'm': case 'g':
    6707                 :      67056 :       if (! strncmp (name + 1, "no-", 3))
    6708                 :            :         {
    6709                 :            :           /* We have Xno-YYY, search for XYYY.  */
    6710                 :      29512 :           for (i = switchnum + 1; i < n_switches; i++)
    6711                 :      25079 :             if (switches[i].part1[0] == name[0]
    6712                 :       4672 :                 && ! strcmp (&switches[i].part1[1], &name[4]))
    6713                 :            :               {
    6714                 :            :                 /* --specs are validated with the validate_switches mechanism.  */
    6715                 :          0 :                 if (switches[switchnum].known)
    6716                 :          0 :                   switches[switchnum].validated = true;
    6717                 :          0 :                 switches[switchnum].live_cond = SWITCH_FALSE;
    6718                 :          0 :                 return 0;
    6719                 :            :               }
    6720                 :            :         }
    6721                 :            :       else
    6722                 :            :         {
    6723                 :            :           /* We have XYYY, search for Xno-YYY.  */
    6724                 :     467990 :           for (i = switchnum + 1; i < n_switches; i++)
    6725                 :     405367 :             if (switches[i].part1[0] == name[0]
    6726                 :      74937 :                 && switches[i].part1[1] == 'n'
    6727                 :      11700 :                 && switches[i].part1[2] == 'o'
    6728                 :      11700 :                 && switches[i].part1[3] == '-'
    6729                 :      11680 :                 && !strcmp (&switches[i].part1[4], &name[1]))
    6730                 :            :               {
    6731                 :            :                 /* --specs are validated with the validate_switches mechanism.  */
    6732                 :          0 :                 if (switches[switchnum].known)
    6733                 :          0 :                   switches[switchnum].validated = true;
    6734                 :          0 :                 switches[switchnum].live_cond = SWITCH_FALSE;
    6735                 :          0 :                 return 0;
    6736                 :            :               }
    6737                 :            :         }
    6738                 :            :       break;
    6739                 :            :     }
    6740                 :            : 
    6741                 :            :   /* Otherwise the switch is live.  */
    6742                 :     525071 :   switches[switchnum].live_cond |= SWITCH_LIVE;
    6743                 :     525071 :   return 1;
    6744                 :            : }
    6745                 :            : 
    6746                 :            : /* Pass a switch to the current accumulating command
    6747                 :            :    in the same form that we received it.
    6748                 :            :    SWITCHNUM identifies the switch; it is an index into
    6749                 :            :    the vector of switches gcc received, which is `switches'.
    6750                 :            :    This cannot fail since it never finishes a command line.
    6751                 :            : 
    6752                 :            :    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
    6753                 :            : 
    6754                 :            : static void
    6755                 :    3404720 : give_switch (int switchnum, int omit_first_word)
    6756                 :            : {
    6757                 :    3404720 :   if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
    6758                 :            :     return;
    6759                 :            : 
    6760                 :    3404720 :   if (!omit_first_word)
    6761                 :            :     {
    6762                 :    3280560 :       do_spec_1 ("-", 0, NULL);
    6763                 :    3280560 :       do_spec_1 (switches[switchnum].part1, 1, NULL);
    6764                 :            :     }
    6765                 :            : 
    6766                 :    3404720 :   if (switches[switchnum].args != 0)
    6767                 :            :     {
    6768                 :            :       const char **p;
    6769                 :    2215560 :       for (p = switches[switchnum].args; *p; p++)
    6770                 :            :         {
    6771                 :    1107780 :           const char *arg = *p;
    6772                 :            : 
    6773                 :    1107780 :           do_spec_1 (" ", 0, NULL);
    6774                 :    1107780 :           if (suffix_subst)
    6775                 :            :             {
    6776                 :       4845 :               unsigned length = strlen (arg);
    6777                 :       4845 :               int dot = 0;
    6778                 :            : 
    6779                 :       9690 :               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
    6780                 :       9690 :                 if (arg[length] == '.')
    6781                 :            :                   {
    6782                 :       4845 :                     (CONST_CAST (char *, arg))[length] = 0;
    6783                 :       4845 :                     dot = 1;
    6784                 :       4845 :                     break;
    6785                 :            :                   }
    6786                 :       4845 :               do_spec_1 (arg, 1, NULL);
    6787                 :       4845 :               if (dot)
    6788                 :       4845 :                 (CONST_CAST (char *, arg))[length] = '.';
    6789                 :       4845 :               do_spec_1 (suffix_subst, 1, NULL);
    6790                 :            :             }
    6791                 :            :           else
    6792                 :    1102940 :             do_spec_1 (arg, 1, NULL);
    6793                 :            :         }
    6794                 :            :     }
    6795                 :            : 
    6796                 :    3404720 :   do_spec_1 (" ", 0, NULL);
    6797                 :    3404720 :   switches[switchnum].validated = true;
    6798                 :            : }
    6799                 :            : 
    6800                 :            : /* Print GCC configuration (e.g. version, thread model, target,
    6801                 :            :    configuration_arguments) to a given FILE.  */
    6802                 :            : 
    6803                 :            : static void
    6804                 :        762 : print_configuration (FILE *file)
    6805                 :            : {
    6806                 :        762 :   int n;
    6807                 :        762 :   const char *thrmod;
    6808                 :            : 
    6809                 :        762 :   fnotice (file, "Target: %s\n", spec_machine);
    6810                 :        762 :   fnotice (file, "Configured with: %s\n", configuration_arguments);
    6811                 :            : 
    6812                 :            : #ifdef THREAD_MODEL_SPEC
    6813                 :            :   /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
    6814                 :            :   but there's no point in doing all this processing just to get
    6815                 :            :   thread_model back.  */
    6816                 :            :   obstack_init (&obstack);
    6817                 :            :   do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
    6818                 :            :   obstack_1grow (&obstack, '\0');
    6819                 :            :   thrmod = XOBFINISH (&obstack, const char *);
    6820                 :            : #else
    6821                 :        762 :   thrmod = thread_model;
    6822                 :            : #endif
    6823                 :            : 
    6824                 :        762 :   fnotice (file, "Thread model: %s\n", thrmod);
    6825                 :        762 :   fnotice (file, "Supported LTO compression algorithms: zlib");
    6826                 :            : #ifdef HAVE_ZSTD_H
    6827                 :        762 :   fnotice (file, " zstd");
    6828                 :            : #endif
    6829                 :        762 :   fnotice (file, "\n");
    6830                 :            : 
    6831                 :            :   /* compiler_version is truncated at the first space when initialized
    6832                 :            :   from version string, so truncate version_string at the first space
    6833                 :            :   before comparing.  */
    6834                 :       5334 :   for (n = 0; version_string[n]; n++)
    6835                 :       5334 :     if (version_string[n] == ' ')
    6836                 :            :       break;
    6837                 :            : 
    6838                 :        762 :   if (! strncmp (version_string, compiler_version, n)
    6839                 :        762 :       && compiler_version[n] == 0)
    6840                 :        762 :     fnotice (file, "gcc version %s %s\n", version_string,
    6841                 :            :              pkgversion_string);
    6842                 :            :   else
    6843                 :          0 :     fnotice (file, "gcc driver version %s %sexecuting gcc version %s\n",
    6844                 :            :              version_string, pkgversion_string, compiler_version);
    6845                 :            : 
    6846                 :        762 : }
    6847                 :            : 
    6848                 :            : #define RETRY_ICE_ATTEMPTS 3
    6849                 :            : 
    6850                 :            : /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise.  */
    6851                 :            : 
    6852                 :            : static bool
    6853                 :          0 : files_equal_p (char *file1, char *file2)
    6854                 :            : {
    6855                 :          0 :   struct stat st1, st2;
    6856                 :          0 :   off_t n, len;
    6857                 :          0 :   int fd1, fd2;
    6858                 :          0 :   const int bufsize = 8192;
    6859                 :          0 :   char *buf = XNEWVEC (char, bufsize);
    6860                 :            : 
    6861                 :          0 :   fd1 = open (file1, O_RDONLY);
    6862                 :          0 :   fd2 = open (file2, O_RDONLY);
    6863                 :            : 
    6864                 :          0 :   if (fd1 < 0 || fd2 < 0)
    6865                 :          0 :     goto error;
    6866                 :            : 
    6867                 :          0 :   if (fstat (fd1, &st1) < 0 || fstat (fd2, &st2) < 0)
    6868                 :          0 :     goto error;
    6869                 :            : 
    6870                 :          0 :   if (st1.st_size != st2.st_size)
    6871                 :          0 :     goto error;
    6872                 :            : 
    6873                 :          0 :   for (n = st1.st_size; n; n -= len)
    6874                 :            :     {
    6875                 :          0 :       len = n;
    6876                 :          0 :       if ((int) len > bufsize / 2)
    6877                 :          0 :         len = bufsize / 2;
    6878                 :            : 
    6879                 :          0 :       if (read (fd1, buf, len) != (int) len
    6880                 :          0 :           || read (fd2, buf + bufsize / 2, len) != (int) len)
    6881                 :            :         {
    6882                 :          0 :           goto error;
    6883                 :            :         }
    6884                 :            : 
    6885                 :          0 :       if (memcmp (buf, buf + bufsize / 2, len) != 0)
    6886                 :          0 :         goto error;
    6887                 :            :     }
    6888                 :            : 
    6889                 :          0 :   free (buf);
    6890                 :          0 :   close (fd1);
    6891                 :          0 :   close (fd2);
    6892                 :            : 
    6893                 :          0 :   return 1;
    6894                 :            : 
    6895                 :          0 : error:
    6896                 :          0 :   free (buf);
    6897                 :          0 :   close (fd1);
    6898                 :          0 :   close (fd2);
    6899                 :          0 :   return 0;
    6900                 :            : }
    6901                 :            : 
    6902                 :            : /* Check that compiler's output doesn't differ across runs.
    6903                 :            :    TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
    6904                 :            :    stdout and stderr for each compiler run.  Return true if all of
    6905                 :            :    TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent.  */
    6906                 :            : 
    6907                 :            : static bool
    6908                 :          0 : check_repro (char **temp_stdout_files, char **temp_stderr_files)
    6909                 :            : {
    6910                 :          0 :   int i;
    6911                 :          0 :   for (i = 0; i < RETRY_ICE_ATTEMPTS - 2; ++i)
    6912                 :            :     {
    6913                 :          0 :      if (!files_equal_p (temp_stdout_files[i], temp_stdout_files[i + 1])
    6914                 :          0 :          || !files_equal_p (temp_stderr_files[i], temp_stderr_files[i + 1]))
    6915                 :            :        {
    6916                 :          0 :          fnotice (stderr, "The bug is not reproducible, so it is"
    6917                 :            :                   " likely a hardware or OS problem.\n");
    6918                 :          0 :          break;
    6919                 :            :        }
    6920                 :            :     }
    6921                 :          0 :   return i == RETRY_ICE_ATTEMPTS - 2;
    6922                 :            : }
    6923                 :            : 
    6924                 :            : enum attempt_status {
    6925                 :            :   ATTEMPT_STATUS_FAIL_TO_RUN,
    6926                 :            :   ATTEMPT_STATUS_SUCCESS,
    6927                 :            :   ATTEMPT_STATUS_ICE
    6928                 :            : };
    6929                 :            : 
    6930                 :            : 
    6931                 :            : /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
    6932                 :            :    to OUT_TEMP and stderr to ERR_TEMP.  If APPEND is TRUE, append to OUT_TEMP
    6933                 :            :    and ERR_TEMP instead of truncating.  If EMIT_SYSTEM_INFO is TRUE, also write
    6934                 :            :    GCC configuration into to ERR_TEMP.  Return ATTEMPT_STATUS_FAIL_TO_RUN if
    6935                 :            :    compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
    6936                 :            :    ATTEMPT_STATUS_SUCCESS otherwise.  */
    6937                 :            : 
    6938                 :            : static enum attempt_status
    6939                 :          0 : run_attempt (const char **new_argv, const char *out_temp,
    6940                 :            :              const char *err_temp, int emit_system_info, int append)
    6941                 :            : {
    6942                 :            : 
    6943                 :          0 :   if (emit_system_info)
    6944                 :            :     {
    6945                 :          0 :       FILE *file_out = fopen (err_temp, "a");
    6946                 :          0 :       print_configuration (file_out);
    6947                 :          0 :       fputs ("\n", file_out);
    6948                 :          0 :       fclose (file_out);
    6949                 :            :     }
    6950                 :            : 
    6951                 :          0 :   int exit_status;
    6952                 :          0 :   const char *errmsg;
    6953                 :          0 :   struct pex_obj *pex;
    6954                 :          0 :   int err;
    6955                 :          0 :   int pex_flags = PEX_USE_PIPES | PEX_LAST;
    6956                 :          0 :   enum attempt_status status = ATTEMPT_STATUS_FAIL_TO_RUN;
    6957                 :            : 
    6958                 :          0 :   if (append)
    6959                 :          0 :     pex_flags |= PEX_STDOUT_APPEND | PEX_STDERR_APPEND;
    6960                 :            : 
    6961                 :          0 :   pex = pex_init (PEX_USE_PIPES, new_argv[0], NULL);
    6962                 :          0 :   if (!pex)
    6963                 :            :     fatal_error (input_location, "%<pex_init%> failed: %m");
    6964                 :            : 
    6965                 :          0 :   errmsg = pex_run (pex, pex_flags, new_argv[0],
    6966                 :          0 :                     CONST_CAST2 (char *const *, const char **, &new_argv[1]),
    6967                 :            :                     out_temp, err_temp, &err);
    6968                 :          0 :   if (errmsg != NULL)
    6969                 :            :     {
    6970                 :          0 :       errno = err;
    6971                 :          0 :       fatal_error (input_location,
    6972                 :            :                    err ? G_ ("cannot execute %qs: %s: %m")
    6973                 :            :                    : G_ ("cannot execute %qs: %s"),
    6974                 :            :                    new_argv[0], errmsg);
    6975                 :            :     }
    6976                 :            : 
    6977                 :          0 :   if (!pex_get_status (pex, 1, &exit_status))
    6978                 :          0 :     goto out;
    6979                 :            : 
    6980                 :          0 :   switch (WEXITSTATUS (exit_status))
    6981                 :            :     {
    6982                 :          0 :       case ICE_EXIT_CODE:
    6983                 :          0 :         status = ATTEMPT_STATUS_ICE;
    6984                 :          0 :         break;
    6985                 :            : 
    6986                 :          0 :       case SUCCESS_EXIT_CODE:
    6987                 :          0 :         status = ATTEMPT_STATUS_SUCCESS;
    6988                 :          0 :         break;
    6989                 :            : 
    6990                 :          0 :       default:
    6991                 :          0 :         ;
    6992                 :            :     }
    6993                 :            : 
    6994                 :          0 : out:
    6995                 :          0 :   pex_free (pex);
    6996                 :          0 :   return status;
    6997                 :            : }
    6998                 :            : 
    6999                 :            : /* This routine reads lines from IN file, adds C++ style comments
    7000                 :            :    at the begining of each line and writes result into OUT.  */
    7001                 :            : 
    7002                 :            : static void
    7003                 :          0 : insert_comments (const char *file_in, const char *file_out)
    7004                 :            : {
    7005                 :          0 :   FILE *in = fopen (file_in, "rb");
    7006                 :          0 :   FILE *out = fopen (file_out, "wb");
    7007                 :          0 :   char line[256];
    7008                 :            : 
    7009                 :          0 :   bool add_comment = true;
    7010                 :          0 :   while (fgets (line, sizeof (line), in))
    7011                 :            :     {
    7012                 :          0 :       if (add_comment)
    7013                 :          0 :         fputs ("// ", out);
    7014                 :          0 :       fputs (line, out);
    7015                 :          0 :       add_comment = strchr (line, '\n') != NULL;
    7016                 :            :     }
    7017                 :            : 
    7018                 :          0 :   fclose (in);
    7019                 :          0 :   fclose (out);
    7020                 :          0 : }
    7021                 :            : 
    7022                 :            : /* This routine adds preprocessed source code into the given ERR_FILE.
    7023                 :            :    To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
    7024                 :            :    add information in report file.  RUN_ATTEMPT should return
    7025                 :            :    ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report.  */
    7026                 :            : 
    7027                 :            : static void
    7028                 :          0 : do_report_bug (const char **new_argv, const int nargs,
    7029                 :            :                char **out_file, char **err_file)
    7030                 :            : {
    7031                 :          0 :   int i, status;
    7032                 :          0 :   int fd = open (*out_file, O_RDWR | O_APPEND);
    7033                 :          0 :   if (fd < 0)
    7034                 :            :     return;
    7035                 :          0 :   write (fd, "\n//", 3);
    7036                 :          0 :   for (i = 0; i < nargs; i++)
    7037                 :            :     {
    7038                 :          0 :       write (fd, " ", 1);
    7039                 :          0 :       write (fd, new_argv[i], strlen (new_argv[i]));
    7040                 :            :     }
    7041                 :          0 :   write (fd, "\n\n", 2);
    7042                 :          0 :   close (fd);
    7043                 :          0 :   new_argv[nargs] = "-E";
    7044                 :          0 :   new_argv[nargs + 1] = NULL;
    7045                 :            : 
    7046                 :          0 :   status = run_attempt (new_argv, *out_file, *err_file, 0, 1);
    7047                 :            : 
    7048                 :          0 :   if (status == ATTEMPT_STATUS_SUCCESS)
    7049                 :            :     {
    7050                 :          0 :       fnotice (stderr, "Preprocessed source stored into %s file,"
    7051                 :            :                " please attach this to your bugreport.\n", *out_file);
    7052                 :            :       /* Make sure it is not deleted.  */
    7053                 :          0 :       free (*out_file);
    7054                 :          0 :       *out_file = NULL;
    7055                 :            :     }
    7056                 :            : }
    7057                 :            : 
    7058                 :            : /* Try to reproduce ICE.  If bug is reproducible, generate report .err file
    7059                 :            :    containing GCC configuration, backtrace, compiler's command line options
    7060                 :            :    and preprocessed source code.  */
    7061                 :            : 
    7062                 :            : static void
    7063                 :          0 : try_generate_repro (const char **argv)
    7064                 :            : {
    7065                 :          0 :   int i, nargs, out_arg = -1, quiet = 0, attempt;
    7066                 :          0 :   const char **new_argv;
    7067                 :          0 :   char *temp_files[RETRY_ICE_ATTEMPTS * 2];
    7068                 :          0 :   char **temp_stdout_files = &temp_files[0];
    7069                 :          0 :   char **temp_stderr_files = &temp_files[RETRY_ICE_ATTEMPTS];
    7070                 :            : 
    7071                 :          0 :   if (gcc_input_filename == NULL || ! strcmp (gcc_input_filename, "-"))
    7072                 :          0 :     return;
    7073                 :            : 
    7074                 :          0 :   for (nargs = 0; argv[nargs] != NULL; ++nargs)
    7075                 :            :     /* Only retry compiler ICEs, not preprocessor ones.  */
    7076                 :          0 :     if (! strcmp (argv[nargs], "-E"))
    7077                 :            :       return;
    7078                 :          0 :     else if (argv[nargs][0] == '-' && argv[nargs][1] == 'o')
    7079                 :            :       {
    7080                 :          0 :         if (out_arg == -1)
    7081                 :            :           out_arg = nargs;
    7082                 :            :         else
    7083                 :            :           return;
    7084                 :            :       }
    7085                 :            :     /* If the compiler is going to output any time information,
    7086                 :            :        it might varry between invocations.  */
    7087                 :          0 :     else if (! strcmp (argv[nargs], "-quiet"))
    7088                 :            :       quiet = 1;
    7089                 :          0 :     else if (! strcmp (argv[nargs], "-ftime-report"))
    7090                 :            :       return;
    7091                 :            : 
    7092                 :          0 :   if (out_arg == -1 || !quiet)
    7093                 :            :     return;
    7094                 :            : 
    7095                 :          0 :   memset (temp_files, '\0', sizeof (temp_files));
    7096                 :          0 :   new_argv = XALLOCAVEC (const char *, nargs + 4);
    7097                 :          0 :   memcpy (new_argv, argv, (nargs + 1) * sizeof (const char *));
    7098                 :          0 :   new_argv[nargs++] = "-frandom-seed=0";
    7099                 :          0 :   new_argv[nargs++] = "-fdump-noaddr";
    7100                 :          0 :   new_argv[nargs] = NULL;
    7101                 :          0 :   if (new_argv[out_arg][2] == '\0')
    7102                 :          0 :     new_argv[out_arg + 1] = "-";
    7103                 :            :   else
    7104                 :          0 :     new_argv[out_arg] = "-o-";
    7105                 :            : 
    7106                 :            :   int status;
    7107                 :          0 :   for (attempt = 0; attempt < RETRY_ICE_ATTEMPTS; ++attempt)
    7108                 :            :     {
    7109                 :          0 :       int emit_system_info = 0;
    7110                 :          0 :       int append = 0;
    7111                 :          0 :       temp_stdout_files[attempt] = make_temp_file (".out");
    7112                 :          0 :       temp_stderr_files[attempt] = make_temp_file (".err");
    7113                 :            : 
    7114                 :          0 :       if (attempt == RETRY_ICE_ATTEMPTS - 1)
    7115                 :            :         {
    7116                 :          0 :           append = 1;
    7117                 :          0 :           emit_system_info = 1;
    7118                 :            :         }
    7119                 :            : 
    7120                 :          0 :       status = run_attempt (new_argv, temp_stdout_files[attempt],
    7121                 :            :                             temp_stderr_files[attempt], emit_system_info,
    7122                 :            :                             append);
    7123                 :            : 
    7124                 :          0 :       if (status != ATTEMPT_STATUS_ICE)
    7125                 :            :         {
    7126                 :          0 :           fnotice (stderr, "The bug is not reproducible, so it is"
    7127                 :            :                    " likely a hardware or OS problem.\n");
    7128                 :          0 :           goto out;
    7129                 :            :         }
    7130                 :            :     }
    7131                 :            : 
    7132                 :          0 :   if (!check_repro (temp_stdout_files, temp_stderr_files))
    7133                 :          0 :     goto out;
    7134                 :            : 
    7135                 :          0 :   {
    7136                 :            :     /* Insert commented out backtrace into report file.  */
    7137                 :          0 :     char **stderr_commented = &temp_stdout_files[RETRY_ICE_ATTEMPTS - 1];
    7138                 :          0 :     insert_comments (temp_stderr_files[RETRY_ICE_ATTEMPTS - 1],
    7139                 :            :                      *stderr_commented);
    7140                 :            : 
    7141                 :            :     /* In final attempt we append compiler options and preprocesssed code to last
    7142                 :            :        generated .out file with configuration and backtrace.  */
    7143                 :          0 :     char **err = &temp_stderr_files[RETRY_ICE_ATTEMPTS - 1];
    7144                 :          0 :     do_report_bug (new_argv, nargs, stderr_commented, err);
    7145                 :            :   }
    7146                 :            : 
    7147                 :            : out:
    7148                 :          0 :   for (i = 0; i < RETRY_ICE_ATTEMPTS * 2; i++)
    7149                 :          0 :     if (temp_files[i])
    7150                 :            :       {
    7151                 :          0 :         unlink (temp_stdout_files[i]);
    7152                 :          0 :         free (temp_stdout_files[i]);
    7153                 :            :       }
    7154                 :            : }
    7155                 :            : 
    7156                 :            : /* Search for a file named NAME trying various prefixes including the
    7157                 :            :    user's -B prefix and some standard ones.
    7158                 :            :    Return the absolute file name found.  If nothing is found, return NAME.  */
    7159                 :            : 
    7160                 :            : static const char *
    7161                 :     414697 : find_file (const char *name)
    7162                 :            : {
    7163                 :     413697 :   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
    7164                 :     414697 :   return newname ? newname : name;
    7165                 :            : }
    7166                 :            : 
    7167                 :            : /* Determine whether a directory exists.  If LINKER, return 0 for
    7168                 :            :    certain fixed names not needed by the linker.  */
    7169                 :            : 
    7170                 :            : static int
    7171                 :    7638150 : is_directory (const char *path1, bool linker)
    7172                 :            : {
    7173                 :    7638150 :   int len1;
    7174                 :    7638150 :   char *path;
    7175                 :    7638150 :   char *cp;
    7176                 :    7638150 :   struct stat st;
    7177                 :            : 
    7178                 :            :   /* Ensure the string ends with "/.".  The resulting path will be a
    7179                 :            :      directory even if the given path is a symbolic link.  */
    7180                 :    7638150 :   len1 = strlen (path1);
    7181                 :    7638150 :   path = (char *) alloca (3 + len1);
    7182                 :    7638150 :   memcpy (path, path1, len1);
    7183                 :    7638150 :   cp = path + len1;
    7184                 :    7638150 :   if (!IS_DIR_SEPARATOR (cp[-1]))
    7185                 :    1077650 :     *cp++ = DIR_SEPARATOR;
    7186                 :    7638150 :   *cp++ = '.';
    7187                 :    7638150 :   *cp = '\0';
    7188                 :            : 
    7189                 :            :   /* Exclude directories that the linker is known to search.  */
    7190                 :    7638150 :   if (linker
    7191                 :    2511330 :       && IS_DIR_SEPARATOR (path[0])
    7192                 :   10149500 :       && ((cp - path == 6
    7193                 :      76556 :            && filename_ncmp (path + 1, "lib", 3) == 0)
    7194                 :    2434760 :           || (cp - path == 10
    7195                 :      76556 :               && filename_ncmp (path + 1, "usr", 3) == 0
    7196                 :      76556 :               && IS_DIR_SEPARATOR (path[4])
    7197                 :      76556 :               && filename_ncmp (path + 5, "lib", 3) == 0)))
    7198                 :     153112 :     return 0;
    7199                 :            : 
    7200                 :   12248300 :   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
    7201                 :            : }
    7202                 :            : 
    7203                 :            : /* Set up the various global variables to indicate that we're processing
    7204                 :            :    the input file named FILENAME.  */
    7205                 :            : 
    7206                 :            : void
    7207                 :     574774 : set_input (const char *filename)
    7208                 :            : {
    7209                 :     574774 :   const char *p;
    7210                 :            : 
    7211                 :     574774 :   gcc_input_filename = filename;
    7212                 :     574774 :   input_filename_length = strlen (gcc_input_filename);
    7213                 :     574774 :   input_basename = lbasename (gcc_input_filename);
    7214                 :            : 
    7215                 :            :   /* Find a suffix starting with the last period,
    7216                 :            :      and set basename_length to exclude that suffix.  */
    7217                 :     574774 :   basename_length = strlen (input_basename);
    7218                 :     574774 :   suffixed_basename_length = basename_length;
    7219                 :     574774 :   p = input_basename + basename_length;
    7220                 :    2480380 :   while (p != input_basename && *p != '.')
    7221                 :    1905610 :     --p;
    7222                 :     574774 :   if (*p == '.' && p != input_basename)
    7223                 :            :     {
    7224                 :     416315 :       basename_length = p - input_basename;
    7225                 :     416315 :       input_suffix = p + 1;
    7226                 :            :     }
    7227                 :            :   else
    7228                 :     158459 :     input_suffix = "";
    7229                 :            : 
    7230                 :            :   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
    7231                 :            :      we will need to do a stat on the gcc_input_filename.  The
    7232                 :            :      INPUT_STAT_SET signals that the stat is needed.  */
    7233                 :     574774 :   input_stat_set = 0;
    7234                 :     574774 : }
    7235                 :            : 
    7236                 :            : /* On fatal signals, delete all the temporary files.  */
    7237                 :            : 
    7238                 :            : static void
    7239                 :          0 : fatal_signal (int signum)
    7240                 :            : {
    7241                 :          0 :   signal (signum, SIG_DFL);
    7242                 :          0 :   delete_failure_queue ();
    7243                 :          0 :   delete_temp_files ();
    7244                 :            :   /* Get the same signal again, this time not handled,
    7245                 :            :      so its normal effect occurs.  */
    7246                 :          0 :   kill (getpid (), signum);
    7247                 :          0 : }
    7248                 :            : 
    7249                 :            : /* Compare the contents of the two files named CMPFILE[0] and
    7250                 :            :    CMPFILE[1].  Return zero if they're identical, nonzero
    7251                 :            :    otherwise.  */
    7252                 :            : 
    7253                 :            : static int
    7254                 :        795 : compare_files (char *cmpfile[])
    7255                 :            : {
    7256                 :        795 :   int ret = 0;
    7257                 :        795 :   FILE *temp[2] = { NULL, NULL };
    7258                 :        795 :   int i;
    7259                 :            : 
    7260                 :            : #if HAVE_MMAP_FILE
    7261                 :        795 :   {
    7262                 :        795 :     size_t length[2];
    7263                 :        795 :     void *map[2] = { NULL, NULL };
    7264                 :            : 
    7265                 :       2385 :     for (i = 0; i < 2; i++)
    7266                 :            :       {
    7267                 :       1590 :         struct stat st;
    7268                 :            : 
    7269                 :       1590 :         if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
    7270                 :            :           {
    7271                 :          0 :             error ("%s: could not determine length of compare-debug file %s",
    7272                 :            :                    gcc_input_filename, cmpfile[i]);
    7273                 :          0 :             ret = 1;
    7274                 :          0 :             break;
    7275                 :            :           }
    7276                 :            : 
    7277                 :       1590 :         length[i] = st.st_size;
    7278                 :            :       }
    7279                 :            : 
    7280                 :        795 :     if (!ret && length[0] != length[1])
    7281                 :            :       {
    7282                 :          0 :         error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename);
    7283                 :          0 :         ret = 1;
    7284                 :            :       }
    7285                 :            : 
    7286                 :        795 :     if (!ret)
    7287                 :       2295 :       for (i = 0; i < 2; i++)
    7288                 :            :         {
    7289                 :       1545 :           int fd = open (cmpfile[i], O_RDONLY);
    7290                 :       1545 :           if (fd < 0)
    7291                 :            :             {
    7292                 :          0 :               error ("%s: could not open compare-debug file %s",
    7293                 :            :                      gcc_input_filename, cmpfile[i]);
    7294                 :          0 :               ret = 1;
    7295                 :          0 :               break;
    7296                 :            :             }
    7297                 :            : 
    7298                 :       1545 :           map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
    7299                 :       1545 :           close (fd);
    7300                 :            : 
    7301                 :       1545 :           if (map[i] == (void *) MAP_FAILED)
    7302                 :            :             {
    7303                 :            :               ret = -1;
    7304                 :            :               break;
    7305                 :            :             }
    7306                 :            :         }
    7307                 :            : 
    7308                 :        795 :     if (!ret)
    7309                 :            :       {
    7310                 :        750 :         if (memcmp (map[0], map[1], length[0]) != 0)
    7311                 :            :           {
    7312                 :          0 :             error ("%s: %<-fcompare-debug%> failure", gcc_input_filename);
    7313                 :          0 :             ret = 1;
    7314                 :            :           }
    7315                 :            :       }
    7316                 :            : 
    7317                 :       2385 :     for (i = 0; i < 2; i++)
    7318                 :       1590 :       if (map[i])
    7319                 :       1545 :         munmap ((caddr_t) map[i], length[i]);
    7320                 :            : 
    7321                 :        795 :     if (ret >= 0)
    7322                 :        750 :       return ret;
    7323                 :            : 
    7324                 :         45 :     ret = 0;
    7325                 :            :   }
    7326                 :            : #endif
    7327                 :            : 
    7328                 :        135 :   for (i = 0; i < 2; i++)
    7329                 :            :     {
    7330                 :         90 :       temp[i] = fopen (cmpfile[i], "r");
    7331                 :         90 :       if (!temp[i])
    7332                 :            :         {
    7333                 :          0 :           error ("%s: could not open compare-debug file %s",
    7334                 :            :                  gcc_input_filename, cmpfile[i]);
    7335                 :          0 :           ret = 1;
    7336                 :          0 :           break;
    7337                 :            :         }
    7338                 :            :     }
    7339                 :            : 
    7340                 :         45 :   if (!ret && temp[0] && temp[1])
    7341                 :         45 :     for (;;)
    7342                 :            :       {
    7343                 :         45 :         int c0, c1;
    7344                 :         45 :         c0 = fgetc (temp[0]);
    7345                 :         45 :         c1 = fgetc (temp[1]);
    7346                 :            : 
    7347                 :         45 :         if (c0 != c1)
    7348                 :            :           {
    7349                 :          0 :             error ("%s: %<-fcompare-debug%> failure",
    7350                 :            :                    gcc_input_filename);
    7351                 :          0 :             ret = 1;
    7352                 :          0 :             break;
    7353                 :            :           }
    7354                 :            : 
    7355                 :         45 :         if (c0 == EOF)
    7356                 :            :           break;
    7357                 :            :       }
    7358                 :            : 
    7359                 :        135 :   for (i = 1; i >= 0; i--)
    7360                 :            :     {
    7361                 :         90 :       if (temp[i])
    7362                 :         90 :         fclose (temp[i]);
    7363                 :            :     }
    7364                 :            : 
    7365                 :            :   return ret;
    7366                 :            : }
    7367                 :            : 
    7368                 :     203006 : driver::driver (bool can_finalize, bool debug) :
    7369                 :            :   explicit_link_files (NULL),
    7370                 :     203006 :   decoded_options (NULL)
    7371                 :            : {
    7372                 :     203006 :   env.init (can_finalize, debug);
    7373                 :     203006 : }
    7374                 :            : 
    7375                 :     405168 : driver::~driver ()
    7376                 :            : {
    7377                 :     202584 :   XDELETEVEC (explicit_link_files);
    7378                 :     202584 :   XDELETEVEC (decoded_options);
    7379                 :     202584 : }
    7380                 :            : 
    7381                 :            : /* driver::main is implemented as a series of driver:: method calls.  */
    7382                 :            : 
    7383                 :            : int
    7384                 :     203006 : driver::main (int argc, char **argv)
    7385                 :            : {
    7386                 :     203006 :   bool early_exit;
    7387                 :            : 
    7388                 :     203006 :   set_progname (argv[0]);
    7389                 :     203006 :   expand_at_files (&argc, &argv);
    7390                 :     203006 :   decode_argv (argc, const_cast <const char **> (argv));
    7391                 :     203006 :   global_initializations ();
    7392                 :     203006 :   build_multilib_strings ();
    7393                 :     203006 :   set_up_specs ();
    7394                 :     202735 :   putenv_COLLECT_AS_OPTIONS (assembler_options);
    7395                 :     202735 :   putenv_COLLECT_GCC (argv[0]);
    7396                 :     202735 :   maybe_putenv_COLLECT_LTO_WRAPPER ();
    7397                 :     202735 :   maybe_putenv_OFFLOAD_TARGETS ();
    7398                 :     202735 :   handle_unrecognized_options ();
    7399                 :            : 
    7400                 :     202735 :   if (completion)
    7401                 :            :     {
    7402                 :          5 :       m_option_proposer.suggest_completion (completion);
    7403                 :          5 :       return 0;
    7404                 :            :     }
    7405                 :            : 
    7406                 :     202730 :   if (!maybe_print_and_exit ())
    7407                 :            :     return 0;
    7408                 :            : 
    7409                 :     200123 :   early_exit = prepare_infiles ();
    7410                 :     199973 :   if (early_exit)
    7411                 :        207 :     return get_exit_code ();
    7412                 :            : 
    7413                 :     199766 :   do_spec_on_infiles ();
    7414                 :     199766 :   maybe_run_linker (argv[0]);
    7415                 :     199766 :   final_actions ();
    7416                 :     199766 :   return get_exit_code ();
    7417                 :            : }
    7418                 :            : 
    7419                 :            : /* Locate the final component of argv[0] after any leading path, and set
    7420                 :            :    the program name accordingly.  */
    7421                 :            : 
    7422                 :            : void
    7423                 :     203006 : driver::set_progname (const char *argv0) const
    7424                 :            : {
    7425                 :     203006 :   const char *p = argv0 + strlen (argv0);
    7426                 :    1137840 :   while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
    7427                 :     934836 :     --p;
    7428                 :     203006 :   progname = p;
    7429                 :            : 
    7430                 :     203006 :   xmalloc_set_program_name (progname);
    7431                 :     203006 : }
    7432                 :            : 
    7433                 :            : /* Expand any @ files within the command-line args,
    7434                 :            :    setting at_file_supplied if any were expanded.  */
    7435                 :            : 
    7436                 :            : void
    7437                 :     203006 : driver::expand_at_files (int *argc, char ***argv) const
    7438                 :            : {
    7439                 :     203006 :   char **old_argv = *argv;
    7440                 :            : 
    7441                 :     203006 :   expandargv (argc, argv);
    7442                 :            : 
    7443                 :            :   /* Determine if any expansions were made.  */
    7444                 :     203006 :   if (*argv != old_argv)
    7445                 :      13991 :     at_file_supplied = true;
    7446                 :     203006 : }
    7447                 :            : 
    7448                 :            : /* Decode the command-line arguments from argc/argv into the
    7449                 :            :    decoded_options array.  */
    7450                 :            : 
    7451                 :            : void
    7452                 :     203006 : driver::decode_argv (int argc, const char **argv)
    7453                 :            : {
    7454                 :     203006 :   init_opts_obstack ();
    7455                 :     203006 :   init_options_struct (&global_options, &global_options_set);
    7456                 :            : 
    7457                 :     203006 :   decode_cmdline_options_to_array (argc, argv,
    7458                 :            :                                    CL_DRIVER,
    7459                 :            :                                    &decoded_options, &decoded_options_count);
    7460                 :     203006 : }
    7461                 :            : 
    7462                 :            : /* Perform various initializations and setup.  */
    7463                 :            : 
    7464                 :            : void
    7465                 :     203006 : driver::global_initializations ()
    7466                 :            : {
    7467                 :            :   /* Unlock the stdio streams.  */
    7468                 :     203006 :   unlock_std_streams ();
    7469                 :            : 
    7470                 :     203006 :   gcc_init_libintl ();
    7471                 :            : 
    7472                 :     203006 :   diagnostic_initialize (global_dc, 0);
    7473                 :     203006 :   diagnostic_color_init (global_dc);
    7474                 :     203006 :   diagnostic_urls_init (global_dc);
    7475                 :            : 
    7476                 :            : #ifdef GCC_DRIVER_HOST_INITIALIZATION
    7477                 :            :   /* Perform host dependent initialization when needed.  */
    7478                 :            :   GCC_DRIVER_HOST_INITIALIZATION;
    7479                 :            : #endif
    7480                 :            : 
    7481                 :     203006 :   if (atexit (delete_temp_files) != 0)
    7482                 :          0 :     fatal_error (input_location, "atexit failed");
    7483                 :            : 
    7484                 :     203006 :   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
    7485                 :     202813 :     signal (SIGINT, fatal_signal);
    7486                 :            : #ifdef SIGHUP
    7487                 :     203006 :   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
    7488                 :      15996 :     signal (SIGHUP, fatal_signal);
    7489                 :            : #endif
    7490                 :     203006 :   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
    7491                 :     203006 :     signal (SIGTERM, fatal_signal);
    7492                 :            : #ifdef SIGPIPE
    7493                 :     203006 :   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
    7494                 :     203006 :     signal (SIGPIPE, fatal_signal);
    7495                 :            : #endif
    7496                 :            : #ifdef SIGCHLD
    7497                 :            :   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
    7498                 :            :      receive the signal.  A different setting is inheritable */
    7499                 :     203006 :   signal (SIGCHLD, SIG_DFL);
    7500                 :            : #endif
    7501                 :            : 
    7502                 :            :   /* Parsing and gimplification sometimes need quite large stack.
    7503                 :            :      Increase stack size limits if possible.  */
    7504                 :     203006 :   stack_limit_increase (64 * 1024 * 1024);
    7505                 :            : 
    7506                 :            :   /* Allocate the argument vector.  */
    7507                 :     203006 :   alloc_args ();
    7508                 :            : 
    7509                 :     203006 :   obstack_init (&obstack);
    7510                 :     203006 : }
    7511                 :            : 
    7512                 :            : /* Build multilib_select, et. al from the separate lines that make up each
    7513                 :            :    multilib selection.  */
    7514                 :            : 
    7515                 :            : void
    7516                 :     203006 : driver::build_multilib_strings () const
    7517                 :            : {
    7518                 :     203006 :   {
    7519                 :     203006 :     const char *p;
    7520                 :     203006 :     const char *const *q = multilib_raw;
    7521                 :     203006 :     int need_space;
    7522                 :            : 
    7523                 :     203006 :     obstack_init (&multilib_obstack);
    7524                 :     812024 :     while ((p = *q++) != (char *) 0)
    7525                 :     609018 :       obstack_grow (&multilib_obstack, p, strlen (p));
    7526                 :            : 
    7527                 :     203006 :     obstack_1grow (&multilib_obstack, 0);
    7528                 :     203006 :     multilib_select = XOBFINISH (&multilib_obstack, const char *);
    7529                 :            : 
    7530                 :     203006 :     q = multilib_matches_raw;
    7531                 :     609018 :     while ((p = *q++) != (char *) 0)
    7532                 :     406012 :       obstack_grow (&multilib_obstack, p, strlen (p));
    7533                 :            : 
    7534                 :     203006 :     obstack_1grow (&multilib_obstack, 0);
    7535                 :     203006 :     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
    7536                 :            : 
    7537                 :     203006 :     q = multilib_exclusions_raw;
    7538                 :     203006 :     while ((p = *q++) != (char *) 0)
    7539                 :            :       obstack_grow (&multilib_obstack, p, strlen (p));
    7540                 :            : 
    7541                 :     203006 :     obstack_1grow (&multilib_obstack, 0);
    7542                 :     203006 :     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
    7543                 :            : 
    7544                 :     203006 :     q = multilib_reuse_raw;
    7545                 :     203006 :     while ((p = *q++) != (char *) 0)
    7546                 :            :       obstack_grow (&multilib_obstack, p, strlen (p));
    7547                 :            : 
    7548                 :     203006 :     obstack_1grow (&multilib_obstack, 0);
    7549                 :     203006 :     multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
    7550                 :            : 
    7551                 :     203006 :     need_space = FALSE;
    7552                 :     406012 :     for (size_t i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
    7553                 :            :       {
    7554                 :     203006 :         if (need_space)
    7555                 :          0 :           obstack_1grow (&multilib_obstack, ' ');
    7556                 :     203006 :         obstack_grow (&multilib_obstack,
    7557                 :            :                       multilib_defaults_raw[i],
    7558                 :            :                       strlen (multilib_defaults_raw[i]));
    7559                 :     203006 :         need_space = TRUE;
    7560                 :            :       }
    7561                 :            : 
    7562                 :     203006 :     obstack_1grow (&multilib_obstack, 0);
    7563                 :     203006 :     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
    7564                 :            :   }
    7565                 :     203006 : }
    7566                 :            : 
    7567                 :            : /* Set up the spec-handling machinery.  */
    7568                 :            : 
    7569                 :            : void
    7570                 :     203006 : driver::set_up_specs () const
    7571                 :            : {
    7572                 :     203006 :   const char *spec_machine_suffix;
    7573                 :     203006 :   char *specs_file;
    7574                 :     203006 :   size_t i;
    7575                 :            : 
    7576                 :            : #ifdef INIT_ENVIRONMENT
    7577                 :            :   /* Set up any other necessary machine specific environment variables.  */
    7578                 :            :   xputenv (INIT_ENVIRONMENT);
    7579                 :            : #endif
    7580                 :            : 
    7581                 :            :   /* Make a table of what switches there are (switches, n_switches).
    7582                 :            :      Make a table of specified input files (infiles, n_infiles).
    7583                 :            :      Decode switches that are handled locally.  */
    7584                 :            : 
    7585                 :     203006 :   process_command (decoded_options_count, decoded_options);
    7586                 :            : 
    7587                 :            :   /* Initialize the vector of specs to just the default.
    7588                 :            :      This means one element containing 0s, as a terminator.  */
    7589                 :            : 
    7590                 :     202736 :   compilers = XNEWVAR (struct compiler, sizeof default_compilers);
    7591                 :     202736 :   memcpy (compilers, default_compilers, sizeof default_compilers);
    7592                 :     202736 :   n_compilers = n_default_compilers;
    7593                 :            : 
    7594                 :            :   /* Read specs from a file if there is one.  */
    7595                 :            : 
    7596                 :     202736 :   machine_suffix = concat (spec_host_machine, dir_separator_str, spec_version,
    7597                 :            :                            accel_dir_suffix, dir_separator_str, NULL);
    7598                 :     202736 :   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
    7599                 :            : 
    7600                 :     202736 :   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
    7601                 :            :   /* Read the specs file unless it is a default one.  */
    7602                 :     202736 :   if (specs_file != 0 && strcmp (specs_file, "specs"))
    7603                 :     202423 :     read_specs (specs_file, true, false);
    7604                 :            :   else
    7605                 :        313 :     init_spec ();
    7606                 :            : 
    7607                 :            : #ifdef ACCEL_COMPILER
    7608                 :            :   spec_machine_suffix = machine_suffix;
    7609                 :            : #else
    7610                 :     202736 :   spec_machine_suffix = just_machine_suffix;
    7611                 :            : #endif
    7612                 :            : 
    7613                 :            :   /* We need to check standard_exec_prefix/spec_machine_suffix/specs
    7614                 :            :      for any override of as, ld and libraries.  */
    7615                 :     202736 :   specs_file = (char *) alloca (strlen (standard_exec_prefix)
    7616                 :            :                        + strlen (spec_machine_suffix) + sizeof ("specs"));
    7617                 :     202736 :   strcpy (specs_file, standard_exec_prefix);
    7618                 :     202736 :   strcat (specs_file, spec_machine_suffix);
    7619                 :     202736 :   strcat (specs_file, "specs");
    7620                 :     202736 :   if (access (specs_file, R_OK) == 0)
    7621                 :          0 :     read_specs (specs_file, true, false);
    7622                 :            : 
    7623                 :            :   /* Process any configure-time defaults specified for the command line
    7624                 :            :      options, via OPTION_DEFAULT_SPECS.  */
    7625                 :    2027360 :   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
    7626                 :    1824620 :     do_option_spec (option_default_specs[i].name,
    7627                 :    1824620 :                     option_default_specs[i].spec);
    7628                 :            : 
    7629                 :            :   /* Process DRIVER_SELF_SPECS, adding any new options to the end
    7630                 :            :      of the command line.  */
    7631                 :            : 
    7632                 :    1216420 :   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
    7633                 :    1013680 :     do_self_spec (driver_self_specs[i]);
    7634                 :            : 
    7635                 :            :   /* If not cross-compiling, look for executables in the standard
    7636                 :            :      places.  */
    7637                 :     202736 :   if (*cross_compile == '0')
    7638                 :            :     {
    7639                 :     202736 :       if (*md_exec_prefix)
    7640                 :            :         {
    7641                 :          0 :           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
    7642                 :            :                       PREFIX_PRIORITY_LAST, 0, 0);
    7643                 :            :         }
    7644                 :            :     }
    7645                 :            : 
    7646                 :            :   /* Process sysroot_suffix_spec.  */
    7647                 :     202736 :   if (*sysroot_suffix_spec != 0
    7648                 :          0 :       && !no_sysroot_suffix
    7649                 :     202736 :       && do_spec_2 (sysroot_suffix_spec, NULL) == 0)
    7650                 :            :     {
    7651                 :          0 :       if (argbuf.length () > 1)
    7652                 :          0 :         error ("spec failure: more than one argument to "
    7653                 :            :                "%<SYSROOT_SUFFIX_SPEC%>");
    7654                 :          0 :       else if (argbuf.length () == 1)
    7655                 :          0 :         target_sysroot_suffix = xstrdup (argbuf.last ());
    7656                 :            :     }
    7657                 :            : 
    7658                 :            : #ifdef HAVE_LD_SYSROOT
    7659                 :            :   /* Pass the --sysroot option to the linker, if it supports that.  If
    7660                 :            :      there is a sysroot_suffix_spec, it has already been processed by
    7661                 :            :      this point, so target_system_root really is the system root we
    7662                 :            :      should be using.  */
    7663                 :     202736 :   if (target_system_root)
    7664                 :            :     {
    7665                 :          0 :       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
    7666                 :          0 :       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
    7667                 :          0 :       set_spec ("link", XOBFINISH (&obstack, const char *), false);
    7668                 :            :     }
    7669                 :            : #endif
    7670                 :            : 
    7671                 :            :   /* Process sysroot_hdrs_suffix_spec.  */
    7672                 :     202736 :   if (*sysroot_hdrs_suffix_spec != 0
    7673                 :          0 :       && !no_sysroot_suffix
    7674                 :     202736 :       && do_spec_2 (sysroot_hdrs_suffix_spec, NULL) == 0)
    7675                 :            :     {
    7676                 :          0 :       if (argbuf.length () > 1)
    7677                 :          0 :         error ("spec failure: more than one argument "
    7678                 :            :                "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
    7679                 :          0 :       else if (argbuf.length () == 1)
    7680                 :          0 :         target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
    7681                 :            :     }
    7682                 :            : 
    7683                 :            :   /* Look for startfiles in the standard places.  */
    7684                 :     202736 :   if (*startfile_prefix_spec != 0
    7685                 :          0 :       && do_spec_2 (startfile_prefix_spec, NULL) == 0
    7686                 :     202736 :       && do_spec_1 (" ", 0, NULL) == 0)
    7687                 :            :     {
    7688                 :            :       const char *arg;
    7689                 :            :       int ndx;
    7690                 :          0 :       FOR_EACH_VEC_ELT (argbuf, ndx, arg)
    7691                 :          0 :         add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
    7692                 :            :                               PREFIX_PRIORITY_LAST, 0, 1);
    7693                 :            :     }
    7694                 :            :   /* We should eventually get rid of all these and stick to
    7695                 :            :      startfile_prefix_spec exclusively.  */
    7696                 :     202736 :   else if (*cross_compile == '0' || target_system_root)
    7697                 :            :     {
    7698                 :     202736 :       if (*md_startfile_prefix)
    7699                 :          0 :         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
    7700                 :            :                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
    7701                 :            : 
    7702                 :     202736 :       if (*md_startfile_prefix_1)
    7703                 :          0 :         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
    7704                 :            :                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
    7705                 :            : 
    7706                 :            :       /* If standard_startfile_prefix is relative, base it on
    7707                 :            :          standard_exec_prefix.  This lets us move the installed tree
    7708                 :            :          as a unit.  If GCC_EXEC_PREFIX is defined, base
    7709                 :            :          standard_startfile_prefix on that as well.
    7710                 :            : 
    7711                 :            :          If the prefix is relative, only search it for native compilers;
    7712                 :            :          otherwise we will search a directory containing host libraries.  */
    7713                 :     202736 :       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
    7714                 :            :         add_sysrooted_prefix (&startfile_prefixes,
    7715                 :            :                               standard_startfile_prefix, "BINUTILS",
    7716                 :            :                               PREFIX_PRIORITY_LAST, 0, 1);
    7717                 :     202736 :       else if (*cross_compile == '0')
    7718                 :            :         {
    7719                 :     202736 :           add_prefix (&startfile_prefixes,
    7720                 :     202736 :                       concat (gcc_exec_prefix
    7721                 :     202736 :                               ? gcc_exec_prefix : standard_exec_prefix,
    7722                 :            :                               machine_suffix,
    7723                 :            :                               standard_startfile_prefix, NULL),
    7724                 :            :                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
    7725                 :            :         }
    7726                 :            : 
    7727                 :            :       /* Sysrooted prefixes are relocated because target_system_root is
    7728                 :            :          also relocated by gcc_exec_prefix.  */
    7729                 :     202736 :       if (*standard_startfile_prefix_1)
    7730                 :     202736 :         add_sysrooted_prefix (&startfile_prefixes,
    7731                 :            :                               standard_startfile_prefix_1, "BINUTILS",
    7732                 :            :                               PREFIX_PRIORITY_LAST, 0, 1);
    7733                 :     202736 :       if (*standard_startfile_prefix_2)
    7734                 :     202736 :         add_sysrooted_prefix (&startfile_prefixes,
    7735                 :            :                               standard_startfile_prefix_2, "BINUTILS",
    7736                 :            :                               PREFIX_PRIORITY_LAST, 0, 1);
    7737                 :            :     }
    7738                 :            : 
    7739                 :            :   /* Process any user specified specs in the order given on the command
    7740                 :            :      line.  */
    7741                 :     202738 :   for (struct user_specs *uptr = user_specs_head; uptr; uptr = uptr->next)
    7742                 :            :     {
    7743                 :          3 :       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
    7744                 :            :                                     R_OK, true);
    7745                 :          3 :       read_specs (filename ? filename : uptr->filename, false, true);
    7746                 :            :     }
    7747                 :            : 
    7748                 :            :   /* Process any user self specs.  */
    7749                 :     202735 :   {
    7750                 :     202735 :     struct spec_list *sl;
    7751                 :    9325810 :     for (sl = specs; sl; sl = sl->next)
    7752                 :    9123080 :       if (sl->name_len == sizeof "self_spec" - 1
    7753                 :    1419140 :           && !strcmp (sl->name, "self_spec"))
    7754                 :     202735 :         do_self_spec (*sl->ptr_spec);
    7755                 :            :   }
    7756                 :            : 
    7757                 :     202735 :   if (compare_debug)
    7758                 :            :     {
    7759                 :        797 :       enum save_temps save;
    7760                 :            : 
    7761                 :        797 :       if (!compare_debug_second)
    7762                 :            :         {
    7763                 :        797 :           n_switches_debug_check[1] = n_switches;
    7764                 :        797 :           n_switches_alloc_debug_check[1] = n_switches_alloc;
    7765                 :        797 :           switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
    7766                 :            :                                              n_switches_alloc);
    7767                 :            : 
    7768                 :        797 :           do_self_spec ("%:compare-debug-self-opt()");
    7769                 :        797 :           n_switches_debug_check[0] = n_switches;
    7770                 :        797 :           n_switches_alloc_debug_check[0] = n_switches_alloc;
    7771                 :        797 :           switches_debug_check[0] = switches;
    7772                 :            : 
    7773                 :        797 :           n_switches = n_switches_debug_check[1];
    7774                 :        797 :           n_switches_alloc = n_switches_alloc_debug_check[1];
    7775                 :        797 :           switches = switches_debug_check[1];
    7776                 :            :         }
    7777                 :            : 
    7778                 :            :       /* Avoid crash when computing %j in this early.  */
    7779                 :        797 :       save = save_temps_flag;
    7780                 :        797 :       save_temps_flag = SAVE_TEMPS_NONE;
    7781                 :            : 
    7782                 :        797 :       compare_debug = -compare_debug;
    7783                 :        797 :       do_self_spec ("%:compare-debug-self-opt()");
    7784                 :            : 
    7785                 :        797 :       save_temps_flag = save;
    7786                 :            : 
    7787                 :        797 :       if (!compare_debug_second)
    7788                 :            :         {
    7789                 :        797 :           n_switches_debug_check[1] = n_switches;
    7790                 :        797 :           n_switches_alloc_debug_check[1] = n_switches_alloc;
    7791                 :        797 :           switches_debug_check[1] = switches;
    7792                 :        797 :           compare_debug = -compare_debug;
    7793                 :        797 :           n_switches = n_switches_debug_check[0];
    7794                 :        797 :           n_switches_alloc = n_switches_debug_check[0];
    7795                 :        797 :           switches = switches_debug_check[0];
    7796                 :            :         }
    7797                 :            :     }
    7798                 :            : 
    7799                 :            : 
    7800                 :            :   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
    7801                 :     202735 :   if (gcc_exec_prefix)
    7802                 :     202735 :     gcc_exec_prefix = concat (gcc_exec_prefix, spec_host_machine,
    7803                 :            :                               dir_separator_str, spec_version,
    7804                 :            :                               accel_dir_suffix, dir_separator_str, NULL);
    7805                 :            : 
    7806                 :            :   /* Now we have the specs.
    7807                 :            :      Set the `valid' bits for switches that match anything in any spec.  */
    7808                 :            : 
    7809                 :     202735 :   validate_all_switches ();
    7810                 :            : 
    7811                 :            :   /* Now that we have the switches and the specs, set
    7812                 :            :      the subdirectory based on the options.  */
    7813                 :     202735 :   set_multilib_dir ();
    7814                 :     202735 : }
    7815                 :            : 
    7816                 :            : /* Set up to remember the pathname of gcc and any options
    7817                 :            :    needed for collect.  We use argv[0] instead of progname because
    7818                 :            :    we need the complete pathname.  */
    7819                 :            : 
    7820                 :            : void
    7821                 :     202735 : driver::putenv_COLLECT_GCC (const char *argv0) const
    7822                 :            : {
    7823                 :     202735 :   obstack_init (&collect_obstack);
    7824                 :     202735 :   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
    7825                 :     202735 :   obstack_grow (&collect_obstack, argv0, strlen (argv0) + 1);
    7826                 :     202735 :   xputenv (XOBFINISH (&collect_obstack, char *));
    7827                 :     202735 : }
    7828                 :            : 
    7829                 :            : /* Set up to remember the pathname of the lto wrapper. */
    7830                 :            : 
    7831                 :            : void
    7832                 :     202735 : driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
    7833                 :            : {
    7834                 :     202735 :   char *lto_wrapper_file;
    7835                 :            : 
    7836                 :     202735 :   if (have_c)
    7837                 :            :     lto_wrapper_file = NULL;
    7838                 :            :   else
    7839                 :      75897 :     lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
    7840                 :            :                                     X_OK, false);
    7841                 :      75897 :   if (lto_wrapper_file)
    7842                 :            :     {
    7843                 :      74736 :       lto_wrapper_file = convert_white_space (lto_wrapper_file);
    7844                 :      74736 :       lto_wrapper_spec = lto_wrapper_file;
    7845                 :      74736 :       obstack_init (&collect_obstack);
    7846                 :      74736 :       obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
    7847                 :            :                     sizeof ("COLLECT_LTO_WRAPPER=") - 1);
    7848                 :      74736 :       obstack_grow (&collect_obstack, lto_wrapper_spec,
    7849                 :            :                     strlen (lto_wrapper_spec) + 1);
    7850                 :      74736 :       xputenv (XOBFINISH (&collect_obstack, char *));
    7851                 :            :     }
    7852                 :            : 
    7853                 :     202735 : }
    7854                 :            : 
    7855                 :            : /* Set up to remember the names of offload targets.  */
    7856                 :            : 
    7857                 :            : void
    7858                 :     202735 : driver::maybe_putenv_OFFLOAD_TARGETS () const
    7859                 :            : {
<