OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [gcc.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Compiler driver program that can handle many languages.
2
   Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4
   2010
5
   Free Software Foundation, Inc.
6
 
7
This file is part of GCC.
8
 
9
GCC is free software; you can redistribute it and/or modify it under
10
the terms of the GNU General Public License as published by the Free
11
Software Foundation; either version 3, or (at your option) any later
12
version.
13
 
14
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15
WARRANTY; without even the implied warranty of MERCHANTABILITY or
16
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17
for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with GCC; see the file COPYING3.  If not see
21
<http://www.gnu.org/licenses/>.  */
22
 
23
/* This program is the user interface to the C compiler and possibly to
24
other compilers.  It is used because compilation is a complicated procedure
25
which involves running several programs and passing temporary files between
26
them, forwarding the users switches to those programs selectively,
27
and deleting the temporary files at the end.
28
 
29
CC recognizes how to compile each input file by suffixes in the file names.
30
Once it knows which kind of compilation to perform, the procedure for
31
compilation is specified by a string called a "spec".  */
32
 
33
/* A Short Introduction to Adding a Command-Line Option.
34
 
35
   Before adding a command-line option, consider if it is really
36
   necessary.  Each additional command-line option adds complexity and
37
   is difficult to remove in subsequent versions.
38
 
39
   In the following, consider adding the command-line argument
40
   `--bar'.
41
 
42
   1. Each command-line option is specified in the specs file.  The
43
   notation is described below in the comment entitled "The Specs
44
   Language".  Read it.
45
 
46
   2. In this file, add an entry to "option_map" equating the long
47
   `--' argument version and any shorter, single letter version.  Read
48
   the comments in the declaration of "struct option_map" for an
49
   explanation.  Do not omit the first `-'.
50
 
51
   3. Look in the "specs" file to determine which program or option
52
   list should be given the argument, e.g., "cc1_options".  Add the
53
   appropriate syntax for the shorter option version to the
54
   corresponding "const char *" entry in this file.  Omit the first
55
   `-' from the option.  For example, use `-bar', rather than `--bar'.
56
 
57
   4. If the argument takes an argument, e.g., `--baz argument1',
58
   modify either DEFAULT_SWITCH_TAKES_ARG or
59
   DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h.  Omit the first `-'
60
   from `--baz'.
61
 
62
   5. Document the option in this file's display_help().  If the
63
   option is passed to a subprogram, modify its corresponding
64
   function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
65
   instead.
66
 
67
   6. Compile and test.  Make sure that your new specs file is being
68
   read.  For example, use a debugger to investigate the value of
69
   "specs_file" in main().  */
70
 
71
#include "config.h"
72
#include "system.h"
73
#include "coretypes.h"
74
#include "multilib.h" /* before tm.h */
75
#include "tm.h"
76
#include <signal.h>
77
#if ! defined( SIGCHLD ) && defined( SIGCLD )
78
#  define SIGCHLD SIGCLD
79
#endif
80
#include "xregex.h"
81
#include "obstack.h"
82
#include "intl.h"
83
#include "prefix.h"
84
#include "gcc.h"
85
#include "flags.h"
86
#include "opts.h"
87
 
88
#ifdef HAVE_MMAP_FILE
89
# include <sys/mman.h>
90
# ifdef HAVE_MINCORE
91
/* This is on Solaris.  */
92
#  include <sys/types.h>
93
# endif
94
#endif
95
 
96
#ifndef MAP_FAILED
97
# define MAP_FAILED ((void *)-1)
98
#endif
99
 
100
/* By default there is no special suffix for target executables.  */
101
/* FIXME: when autoconf is fixed, remove the host check - dj */
102
#if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
103
#define HAVE_TARGET_EXECUTABLE_SUFFIX
104
#endif
105
 
106
/* By default there is no special suffix for host executables.  */
107
#ifdef HOST_EXECUTABLE_SUFFIX
108
#define HAVE_HOST_EXECUTABLE_SUFFIX
109
#else
110
#define HOST_EXECUTABLE_SUFFIX ""
111
#endif
112
 
113
/* By default, the suffix for target object files is ".o".  */
114
#ifdef TARGET_OBJECT_SUFFIX
115
#define HAVE_TARGET_OBJECT_SUFFIX
116
#else
117
#define TARGET_OBJECT_SUFFIX ".o"
118
#endif
119
 
120
static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
121
 
122
/* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */
123
#ifndef LIBRARY_PATH_ENV
124
#define LIBRARY_PATH_ENV "LIBRARY_PATH"
125
#endif
126
 
127
#ifndef HAVE_KILL
128
#define kill(p,s) raise(s)
129
#endif
130
 
131
/* If a stage of compilation returns an exit status >= 1,
132
   compilation of that file ceases.  */
133
 
134
#define MIN_FATAL_STATUS 1
135
 
136
/* Flag set by cppspec.c to 1.  */
137
int is_cpp_driver;
138
 
139
/* Flag set to nonzero if an @file argument has been supplied to gcc.  */
140
static bool at_file_supplied;
141
 
142
/* Flag saying to pass the greatest exit code returned by a sub-process
143
   to the calling program.  */
144
static int pass_exit_codes;
145
 
146
/* Definition of string containing the arguments given to configure.  */
147
#include "configargs.h"
148
 
149
/* Flag saying to print the directories gcc will search through looking for
150
   programs, libraries, etc.  */
151
 
152
static int print_search_dirs;
153
 
154
/* Flag saying to print the full filename of this file
155
   as found through our usual search mechanism.  */
156
 
157
static const char *print_file_name = NULL;
158
 
159
/* As print_file_name, but search for executable file.  */
160
 
161
static const char *print_prog_name = NULL;
162
 
163
/* Flag saying to print the relative path we'd use to
164
   find libgcc.a given the current compiler flags.  */
165
 
166
static int print_multi_directory;
167
 
168
static int print_sysroot;
169
 
170
/* Flag saying to print the relative path we'd use to
171
   find OS libraries given the current compiler flags.  */
172
 
173
static int print_multi_os_directory;
174
 
175
/* Flag saying to print the list of subdirectories and
176
   compiler flags used to select them in a standard form.  */
177
 
178
static int print_multi_lib;
179
 
180
/* Flag saying to print the command line options understood by gcc and its
181
   sub-processes.  */
182
 
183
static int print_help_list;
184
 
185
/* Flag saying to print the version of gcc and its sub-processes.  */
186
 
187
static int print_version;
188
 
189
/* Flag saying to print the sysroot suffix used for searching for
190
   headers.  */
191
 
192
static int print_sysroot_headers_suffix;
193
 
194
/* Flag indicating whether we should print the command and arguments */
195
 
196
static int verbose_flag;
197
 
198
/* Flag indicating whether we should ONLY print the command and
199
   arguments (like verbose_flag) without executing the command.
200
   Displayed arguments are quoted so that the generated command
201
   line is suitable for execution.  This is intended for use in
202
   shell scripts to capture the driver-generated command line.  */
203
static int verbose_only_flag;
204
 
205
/* Flag indicating how to print command line options of sub-processes.  */
206
 
207
static int print_subprocess_help;
208
 
209
/* Flag indicating whether we should report subprocess execution times
210
   (if this is supported by the system - see pexecute.c).  */
211
 
212
static int report_times;
213
 
214
/* Whether we should report subprocess execution times to a file.  */
215
 
216
FILE *report_times_to_file = NULL;
217
 
218
/* Nonzero means place this string before uses of /, so that include
219
   and library files can be found in an alternate location.  */
220
 
221
#ifdef TARGET_SYSTEM_ROOT
222
static const char *target_system_root = TARGET_SYSTEM_ROOT;
223
#else
224
static const char *target_system_root = 0;
225
#endif
226
 
227
/* Nonzero means pass the updated target_system_root to the compiler.  */
228
 
229
static int target_system_root_changed;
230
 
231
/* Nonzero means append this string to target_system_root.  */
232
 
233
static const char *target_sysroot_suffix = 0;
234
 
235
/* Nonzero means append this string to target_system_root for headers.  */
236
 
237
static const char *target_sysroot_hdrs_suffix = 0;
238
 
239
/* Nonzero means write "temp" files in source directory
240
   and use the source file's name in them, and don't delete them.  */
241
 
242
static enum save_temps {
243
  SAVE_TEMPS_NONE,              /* no -save-temps */
244
  SAVE_TEMPS_CWD,               /* -save-temps in current directory */
245
  SAVE_TEMPS_OBJ                /* -save-temps in object directory */
246
} save_temps_flag;
247
 
248
/* Output file to use to get the object directory for -save-temps=obj  */
249
static char *save_temps_prefix = 0;
250
static size_t save_temps_length = 0;
251
 
252
/* Nonzero means pass multiple source files to the compiler at one time.  */
253
 
254
static int combine_flag = 0;
255
 
256
/* Nonzero means use pipes to communicate between subprocesses.
257
   Overridden by either of the above two flags.  */
258
 
259
static int use_pipes;
260
 
261
/* The compiler version.  */
262
 
263
static const char *compiler_version;
264
 
265
/* The target version specified with -V */
266
 
267
static const char *const spec_version = DEFAULT_TARGET_VERSION;
268
 
269
/* The target machine specified with -b.  */
270
 
271
static const char *spec_machine = DEFAULT_TARGET_MACHINE;
272
 
273
/* Nonzero if cross-compiling.
274
   When -b is used, the value comes from the `specs' file.  */
275
 
276
#ifdef CROSS_DIRECTORY_STRUCTURE
277
static const char *cross_compile = "1";
278
#else
279
static const char *cross_compile = "0";
280
#endif
281
 
282
#ifdef MODIFY_TARGET_NAME
283
 
284
/* Information on how to alter the target name based on a command-line
285
   switch.  The only case we support now is simply appending or deleting a
286
   string to or from the end of the first part of the configuration name.  */
287
 
288
enum add_del {ADD, DELETE};
289
 
290
static const struct modify_target
291
{
292
  const char *const sw;
293
  const enum add_del add_del;
294
  const char *const str;
295
}
296
modify_target[] = MODIFY_TARGET_NAME;
297
#endif
298
 
299
/* The number of errors that have occurred; the link phase will not be
300
   run if this is nonzero.  */
301
static int error_count = 0;
302
 
303
/* Greatest exit code of sub-processes that has been encountered up to
304
   now.  */
305
static int greatest_status = 1;
306
 
307
/* This is the obstack which we use to allocate many strings.  */
308
 
309
static struct obstack obstack;
310
 
311
/* This is the obstack to build an environment variable to pass to
312
   collect2 that describes all of the relevant switches of what to
313
   pass the compiler in building the list of pointers to constructors
314
   and destructors.  */
315
 
316
static struct obstack collect_obstack;
317
 
318
/* This is a list of a wrapper program and its arguments.
319
   e.g. wrapper_string of "strace,-c"
320
   will cause all programs to run as
321
       strace -c program arguments
322
   instead of just
323
       program arguments */
324
static const char  *wrapper_string;
325
 
326
/* Forward declaration for prototypes.  */
327
struct path_prefix;
328
struct prefix_list;
329
 
330
static void init_spec (void);
331
static void store_arg (const char *, int, int);
332
static void insert_wrapper (const char *);
333
static char *load_specs (const char *);
334
static void read_specs (const char *, int);
335
static void set_spec (const char *, const char *);
336
static struct compiler *lookup_compiler (const char *, size_t, const char *);
337
static char *build_search_list (const struct path_prefix *, const char *,
338
                                bool, bool);
339
static void xputenv (const char *);
340
static void putenv_from_prefixes (const struct path_prefix *, const char *,
341
                                  bool);
342
static int access_check (const char *, int);
343
static char *find_a_file (const struct path_prefix *, const char *, int, bool);
344
static void add_prefix (struct path_prefix *, const char *, const char *,
345
                        int, int, int);
346
static void add_sysrooted_prefix (struct path_prefix *, const char *,
347
                                  const char *, int, int, int);
348
static void translate_options (int *, const char *const **);
349
static char *skip_whitespace (char *);
350
static void delete_if_ordinary (const char *);
351
static void delete_temp_files (void);
352
static void delete_failure_queue (void);
353
static void clear_failure_queue (void);
354
static int check_live_switch (int, int);
355
static const char *handle_braces (const char *);
356
static inline bool input_suffix_matches (const char *, const char *);
357
static inline bool switch_matches (const char *, const char *, int);
358
static inline void mark_matching_switches (const char *, const char *, int);
359
static inline void process_marked_switches (void);
360
static const char *process_brace_body (const char *, const char *, const char *, int, int);
361
static const struct spec_function *lookup_spec_function (const char *);
362
static const char *eval_spec_function (const char *, const char *);
363
static const char *handle_spec_function (const char *);
364
static char *save_string (const char *, int);
365
static void set_collect_gcc_options (void);
366
static int do_spec_1 (const char *, int, const char *);
367
static int do_spec_2 (const char *);
368
static void do_option_spec (const char *, const char *);
369
static void do_self_spec (const char *);
370
static const char *find_file (const char *);
371
static int is_directory (const char *, bool);
372
static const char *validate_switches (const char *);
373
static void validate_all_switches (void);
374
static inline void validate_switches_from_spec (const char *);
375
static void give_switch (int, int);
376
static int used_arg (const char *, int);
377
static int default_arg (const char *, int);
378
static void set_multilib_dir (void);
379
static void print_multilib_info (void);
380
static void perror_with_name (const char *);
381
static void fatal_ice (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
382
static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
383
static void display_help (void);
384
static void add_preprocessor_option (const char *, int);
385
static void add_assembler_option (const char *, int);
386
static void add_linker_option (const char *, int);
387
static void process_command (int, const char **);
388
static int execute (void);
389
static void alloc_args (void);
390
static void clear_args (void);
391
static void fatal_error (int);
392
#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
393
static void init_gcc_specs (struct obstack *, const char *, const char *,
394
                            const char *);
395
#endif
396
#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
397
static const char *convert_filename (const char *, int, int);
398
#endif
399
 
400
static const char *getenv_spec_function (int, const char **);
401
static const char *if_exists_spec_function (int, const char **);
402
static const char *if_exists_else_spec_function (int, const char **);
403
static const char *replace_outfile_spec_function (int, const char **);
404
static const char *version_compare_spec_function (int, const char **);
405
static const char *include_spec_function (int, const char **);
406
static const char *print_asm_header_spec_function (int, const char **);
407
static const char *compare_debug_dump_opt_spec_function (int, const char **);
408
static const char *compare_debug_self_opt_spec_function (int, const char **);
409
static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
410
 
411
/* The Specs Language
412
 
413
Specs are strings containing lines, each of which (if not blank)
414
is made up of a program name, and arguments separated by spaces.
415
The program name must be exact and start from root, since no path
416
is searched and it is unreliable to depend on the current working directory.
417
Redirection of input or output is not supported; the subprograms must
418
accept filenames saying what files to read and write.
419
 
420
In addition, the specs can contain %-sequences to substitute variable text
421
or for conditional text.  Here is a table of all defined %-sequences.
422
Note that spaces are not generated automatically around the results of
423
expanding these sequences; therefore, you can concatenate them together
424
or with constant text in a single argument.
425
 
426
 %%     substitute one % into the program name or argument.
427
 %i     substitute the name of the input file being processed.
428
 %b     substitute the basename of the input file being processed.
429
        This is the substring up to (and not including) the last period
430
        and not including the directory unless -save-temps was specified
431
        to put temporaries in a different location.
432
 %B     same as %b, but include the file suffix (text after the last period).
433
 %gSUFFIX
434
        substitute a file name that has suffix SUFFIX and is chosen
435
        once per compilation, and mark the argument a la %d.  To reduce
436
        exposure to denial-of-service attacks, the file name is now
437
        chosen in a way that is hard to predict even when previously
438
        chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
439
        might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
440
        the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
441
        had been pre-processed.  Previously, %g was simply substituted
442
        with a file name chosen once per compilation, without regard
443
        to any appended suffix (which was therefore treated just like
444
        ordinary text), making such attacks more likely to succeed.
445
 %|SUFFIX
446
        like %g, but if -pipe is in effect, expands simply to "-".
447
 %mSUFFIX
448
        like %g, but if -pipe is in effect, expands to nothing.  (We have both
449
        %| and %m to accommodate differences between system assemblers; see
450
        the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
451
 %uSUFFIX
452
        like %g, but generates a new temporary file name even if %uSUFFIX
453
        was already seen.
454
 %USUFFIX
455
        substitutes the last file name generated with %uSUFFIX, generating a
456
        new one if there is no such last file name.  In the absence of any
457
        %uSUFFIX, this is just like %gSUFFIX, except they don't share
458
        the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
459
        would involve the generation of two distinct file names, one
460
        for each `%g.s' and another for each `%U.s'.  Previously, %U was
461
        simply substituted with a file name chosen for the previous %u,
462
        without regard to any appended suffix.
463
 %jSUFFIX
464
        substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
465
        writable, and if save-temps is off; otherwise, substitute the name
466
        of a temporary file, just like %u.  This temporary file is not
467
        meant for communication between processes, but rather as a junk
468
        disposal mechanism.
469
 %.SUFFIX
470
        substitutes .SUFFIX for the suffixes of a matched switch's args when
471
        it is subsequently output with %*. SUFFIX is terminated by the next
472
        space or %.
473
 %d     marks the argument containing or following the %d as a
474
        temporary file name, so that that file will be deleted if GCC exits
475
        successfully.  Unlike %g, this contributes no text to the argument.
476
 %w     marks the argument containing or following the %w as the
477
        "output file" of this compilation.  This puts the argument
478
        into the sequence of arguments that %o will substitute later.
479
 %V     indicates that this compilation produces no "output file".
480
 %W{...}
481
        like %{...} but mark last argument supplied within
482
        as a file to be deleted on failure.
483
 %o     substitutes the names of all the output files, with spaces
484
        automatically placed around them.  You should write spaces
485
        around the %o as well or the results are undefined.
486
        %o is for use in the specs for running the linker.
487
        Input files whose names have no recognized suffix are not compiled
488
        at all, but they are included among the output files, so they will
489
        be linked.
490
 %O     substitutes the suffix for object files.  Note that this is
491
        handled specially when it immediately follows %g, %u, or %U
492
        (with or without a suffix argument) because of the need for
493
        those to form complete file names.  The handling is such that
494
        %O is treated exactly as if it had already been substituted,
495
        except that %g, %u, and %U do not currently support additional
496
        SUFFIX characters following %O as they would following, for
497
        example, `.o'.
498
 %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
499
        (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
500
        and -B options) and -imultilib as necessary.
501
 %s     current argument is the name of a library or startup file of some sort.
502
        Search for that file in a standard list of directories
503
        and substitute the full name found.
504
 %eSTR  Print STR as an error message.  STR is terminated by a newline.
505
        Use this when inconsistent options are detected.
506
 %nSTR  Print STR as a notice.  STR is terminated by a newline.
507
 %x{OPTION}     Accumulate an option for %X.
508
 %X     Output the accumulated linker options specified by compilations.
509
 %Y     Output the accumulated assembler options specified by compilations.
510
 %Z     Output the accumulated preprocessor options specified by compilations.
511
 %a     process ASM_SPEC as a spec.
512
        This allows config.h to specify part of the spec for running as.
513
 %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
514
        used here.  This can be used to run a post-processor after the
515
        assembler has done its job.
516
 %D     Dump out a -L option for each directory in startfile_prefixes.
517
        If multilib_dir is set, extra entries are generated with it affixed.
518
 %l     process LINK_SPEC as a spec.
519
 %L     process LIB_SPEC as a spec.
520
 %G     process LIBGCC_SPEC as a spec.
521
 %R     Output the concatenation of target_system_root and
522
        target_sysroot_suffix.
523
 %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
524
 %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
525
 %C     process CPP_SPEC as a spec.
526
 %1     process CC1_SPEC as a spec.
527
 %2     process CC1PLUS_SPEC as a spec.
528
 %*     substitute the variable part of a matched option.  (See below.)
529
        Note that each comma in the substituted string is replaced by
530
        a single space.
531
 %<S    remove all occurrences of -S from the command line.
532
        Note - this command is position dependent.  % commands in the
533
        spec string before this one will see -S, % commands in the
534
        spec string after this one will not.
535
 %<S*   remove all occurrences of all switches beginning with -S from the
536
        command line.
537
 %:function(args)
538
        Call the named function FUNCTION, passing it ARGS.  ARGS is
539
        first processed as a nested spec string, then split into an
540
        argument vector in the usual fashion.  The function returns
541
        a string which is processed as if it had appeared literally
542
        as part of the current spec.
543
 %{S}   substitutes the -S switch, if that switch was given to GCC.
544
        If that switch was not specified, this substitutes nothing.
545
        Here S is a metasyntactic variable.
546
 %{S*}  substitutes all the switches specified to GCC whose names start
547
        with -S.  This is used for -o, -I, etc; switches that take
548
        arguments.  GCC considers `-o foo' as being one switch whose
549
        name starts with `o'.  %{o*} would substitute this text,
550
        including the space; thus, two arguments would be generated.
551
 %{S*&T*} likewise, but preserve order of S and T options (the order
552
        of S and T in the spec is not significant).  Can be any number
553
        of ampersand-separated variables; for each the wild card is
554
        optional.  Useful for CPP as %{D*&U*&A*}.
555
 
556
 %{S:X}   substitutes X, if the -S switch was given to GCC.
557
 %{!S:X}  substitutes X, if the -S switch was NOT given to GCC.
558
 %{S*:X}  substitutes X if one or more switches whose names start
559
          with -S was given to GCC.  Normally X is substituted only
560
          once, no matter how many such switches appeared.  However,
561
          if %* appears somewhere in X, then X will be substituted
562
          once for each matching switch, with the %* replaced by the
563
          part of that switch that matched the '*'.
564
 %{.S:X}  substitutes X, if processing a file with suffix S.
565
 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
566
 %{,S:X}  substitutes X, if processing a file which will use spec S.
567
 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
568
 
569
 %{S|T:X} substitutes X if either -S or -T was given to GCC.  This may be
570
          combined with '!', '.', ',', and '*' as above binding stronger
571
          than the OR.
572
          If %* appears in X, all of the alternatives must be starred, and
573
          only the first matching alternative is substituted.
574
 %{S:X;   if S was given to GCC, substitutes X;
575
   T:Y;   else if T was given to GCC, substitutes Y;
576
    :D}   else substitutes D.  There can be as many clauses as you need.
577
          This may be combined with '.', '!', ',', '|', and '*' as above.
578
 
579
 %(Spec) processes a specification defined in a specs file as *Spec:
580
 %[Spec] as above, but put __ around -D arguments
581
 
582
The conditional text X in a %{S:X} or similar construct may contain
583
other nested % constructs or spaces, or even newlines.  They are
584
processed as usual, as described above.  Trailing white space in X is
585
ignored.  White space may also appear anywhere on the left side of the
586
colon in these constructs, except between . or * and the corresponding
587
word.
588
 
589
The -O, -f, -m, and -W switches are handled specifically in these
590
constructs.  If another value of -O or the negated form of a -f, -m, or
591
-W switch is found later in the command line, the earlier switch
592
value is ignored, except with {S*} where S is just one letter; this
593
passes all matching options.
594
 
595
The character | at the beginning of the predicate text is used to indicate
596
that a command should be piped to the following command, but only if -pipe
597
is specified.
598
 
599
Note that it is built into GCC which switches take arguments and which
600
do not.  You might think it would be useful to generalize this to
601
allow each compiler's spec to say which switches take arguments.  But
602
this cannot be done in a consistent fashion.  GCC cannot even decide
603
which input files have been specified without knowing which switches
604
take arguments, and it must know which input files to compile in order
605
to tell which compilers to run.
606
 
607
GCC also knows implicitly that arguments starting in `-l' are to be
608
treated as compiler output files, and passed to the linker in their
609
proper position among the other output files.  */
610
 
611
/* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
612
 
613
/* config.h can define ASM_SPEC to provide extra args to the assembler
614
   or extra switch-translations.  */
615
#ifndef ASM_SPEC
616
#define ASM_SPEC ""
617
#endif
618
 
619
/* config.h can define ASM_FINAL_SPEC to run a post processor after
620
   the assembler has run.  */
621
#ifndef ASM_FINAL_SPEC
622
#define ASM_FINAL_SPEC ""
623
#endif
624
 
625
/* config.h can define CPP_SPEC to provide extra args to the C preprocessor
626
   or extra switch-translations.  */
627
#ifndef CPP_SPEC
628
#define CPP_SPEC ""
629
#endif
630
 
631
/* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
632
   or extra switch-translations.  */
633
#ifndef CC1_SPEC
634
#define CC1_SPEC ""
635
#endif
636
 
637
/* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
638
   or extra switch-translations.  */
639
#ifndef CC1PLUS_SPEC
640
#define CC1PLUS_SPEC ""
641
#endif
642
 
643
/* config.h can define LINK_SPEC to provide extra args to the linker
644
   or extra switch-translations.  */
645
#ifndef LINK_SPEC
646
#define LINK_SPEC ""
647
#endif
648
 
649
/* config.h can define LIB_SPEC to override the default libraries.  */
650
#ifndef LIB_SPEC
651
#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
652
#endif
653
 
654
/* mudflap specs */
655
#ifndef MFWRAP_SPEC
656
/* XXX: valid only for GNU ld */
657
/* XXX: should exactly match hooks provided by libmudflap.a */
658
#define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
659
 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
660
 --wrap=mmap --wrap=munmap --wrap=alloca\
661
} %{fmudflapth: --wrap=pthread_create\
662
}} %{fmudflap|fmudflapth: --wrap=main}"
663
#endif
664
#ifndef MFLIB_SPEC
665
#define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
666
#endif
667
 
668
/* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
669
   included.  */
670
#ifndef LIBGCC_SPEC
671
#if defined(REAL_LIBGCC_SPEC)
672
#define LIBGCC_SPEC REAL_LIBGCC_SPEC
673
#elif defined(LINK_LIBGCC_SPECIAL_1)
674
/* Have gcc do the search for libgcc.a.  */
675
#define LIBGCC_SPEC "libgcc.a%s"
676
#else
677
#define LIBGCC_SPEC "-lgcc"
678
#endif
679
#endif
680
 
681
/* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
682
#ifndef STARTFILE_SPEC
683
#define STARTFILE_SPEC  \
684
  "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
685
#endif
686
 
687
/* config.h can define SWITCHES_NEED_SPACES to control which options
688
   require spaces between the option and the argument.
689
 
690
   We define SWITCHES_NEED_SPACES to include "o" by default.  This
691
   causes "-ofoo.o" to be split into "-o foo.o" during the initial
692
   processing of the command-line, before being seen by the specs
693
   machinery.  This makes sure we record "foo.o" as the temporary file
694
   to be deleted in the case of error, rather than "-ofoo.o".  */
695
#ifndef SWITCHES_NEED_SPACES
696
#define SWITCHES_NEED_SPACES "o"
697
#endif
698
 
699
/* config.h can define ENDFILE_SPEC to override the default crtn files.  */
700
#ifndef ENDFILE_SPEC
701
#define ENDFILE_SPEC ""
702
#endif
703
 
704
#ifndef LINKER_NAME
705
#define LINKER_NAME "collect2"
706
#endif
707
 
708
#ifdef HAVE_AS_DEBUG_PREFIX_MAP
709
#define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
710
#else
711
#define ASM_MAP ""
712
#endif
713
 
714
/* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
715
   to the assembler.  */
716
#ifndef ASM_DEBUG_SPEC
717
# if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
718
     && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
719
#  define ASM_DEBUG_SPEC                                                \
720
      (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                            \
721
       ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP    \
722
       : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
723
# else
724
#  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
725
#   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
726
#  endif
727
#  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
728
#   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
729
#  endif
730
# endif
731
#endif
732
#ifndef ASM_DEBUG_SPEC
733
# define ASM_DEBUG_SPEC ""
734
#endif
735
 
736
/* Here is the spec for running the linker, after compiling all files.  */
737
 
738
/* This is overridable by the target in case they need to specify the
739
   -lgcc and -lc order specially, yet not require them to override all
740
   of LINK_COMMAND_SPEC.  */
741
#ifndef LINK_GCC_C_SEQUENCE_SPEC
742
#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
743
#endif
744
 
745
#ifndef LINK_SSP_SPEC
746
#ifdef TARGET_LIBC_PROVIDES_SSP
747
#define LINK_SSP_SPEC "%{fstack-protector:}"
748
#else
749
#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
750
#endif
751
#endif
752
 
753
#ifndef LINK_PIE_SPEC
754
#ifdef HAVE_LD_PIE
755
#define LINK_PIE_SPEC "%{pie:-pie} "
756
#else
757
#define LINK_PIE_SPEC "%{pie:} "
758
#endif
759
#endif
760
 
761
#ifndef LINK_BUILDID_SPEC
762
# if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
763
#  define LINK_BUILDID_SPEC "%{!r:--build-id} "
764
# endif
765
#endif
766
 
767
 
768
/* -u* was put back because both BSD and SysV seem to support it.  */
769
/* %{static:} simply prevents an error message if the target machine
770
   doesn't handle -static.  */
771
/* We want %{T*} after %{L*} and %D so that it can be used to specify linker
772
   scripts which exist in user specified directories, or in standard
773
   directories.  */
774
/* We pass any -flto and -fwhopr flags on to the linker, which is expected
775
   to understand them.  In practice, this means it had better be collect2.  */
776
#ifndef LINK_COMMAND_SPEC
777
#define LINK_COMMAND_SPEC "\
778
%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
779
    %(linker) \
780
    %{fuse-linker-plugin: \
781
    -plugin %(linker_plugin_file) \
782
    -plugin-opt=%(lto_wrapper) \
783
    -plugin-opt=%(lto_gcc) \
784
    %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)}     \
785
    %{static:-plugin-opt=-pass-through=-lc}     \
786
    %{O*:-plugin-opt=-O%*} \
787
    %{w:-plugin-opt=-w} \
788
    %{f*:-plugin-opt=-f%*} \
789
    %{m*:-plugin-opt=-m%*} \
790
    %{v:-plugin-opt=-v} \
791
    } \
792
    %{flto} %{fwhopr} %l " LINK_PIE_SPEC \
793
   "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
794
    %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
795
    %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
796
    %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)} %(mflib)\
797
    %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
798
    %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
799
    %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
800
#endif
801
 
802
#ifndef LINK_LIBGCC_SPEC
803
/* Generate -L options for startfile prefix list.  */
804
# define LINK_LIBGCC_SPEC "%D"
805
#endif
806
 
807
#ifndef STARTFILE_PREFIX_SPEC
808
# define STARTFILE_PREFIX_SPEC ""
809
#endif
810
 
811
#ifndef SYSROOT_SPEC
812
# define SYSROOT_SPEC "--sysroot=%R"
813
#endif
814
 
815
#ifndef SYSROOT_SUFFIX_SPEC
816
# define SYSROOT_SUFFIX_SPEC ""
817
#endif
818
 
819
#ifndef SYSROOT_HEADERS_SUFFIX_SPEC
820
# define SYSROOT_HEADERS_SUFFIX_SPEC ""
821
#endif
822
 
823
static const char *asm_debug;
824
static const char *cpp_spec = CPP_SPEC;
825
static const char *cc1_spec = CC1_SPEC;
826
static const char *cc1plus_spec = CC1PLUS_SPEC;
827
static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
828
static const char *link_ssp_spec = LINK_SSP_SPEC;
829
static const char *asm_spec = ASM_SPEC;
830
static const char *asm_final_spec = ASM_FINAL_SPEC;
831
static const char *link_spec = LINK_SPEC;
832
static const char *lib_spec = LIB_SPEC;
833
static const char *mfwrap_spec = MFWRAP_SPEC;
834
static const char *mflib_spec = MFLIB_SPEC;
835
static const char *link_gomp_spec = "";
836
static const char *libgcc_spec = LIBGCC_SPEC;
837
static const char *endfile_spec = ENDFILE_SPEC;
838
static const char *startfile_spec = STARTFILE_SPEC;
839
static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
840
static const char *linker_name_spec = LINKER_NAME;
841
static const char *linker_plugin_file_spec = "";
842
static const char *lto_wrapper_spec = "";
843
static const char *lto_gcc_spec = "";
844
static const char *lto_libgcc_spec = "";
845
static const char *link_command_spec = LINK_COMMAND_SPEC;
846
static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
847
static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
848
static const char *sysroot_spec = SYSROOT_SPEC;
849
static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
850
static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
851
 
852
/* Standard options to cpp, cc1, and as, to reduce duplication in specs.
853
   There should be no need to override these in target dependent files,
854
   but we need to copy them to the specs file so that newer versions
855
   of the GCC driver can correctly drive older tool chains with the
856
   appropriate -B options.  */
857
 
858
/* When cpplib handles traditional preprocessing, get rid of this, and
859
   call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
860
   that we default the front end language better.  */
861
static const char *trad_capable_cpp =
862
"cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
863
 
864
/* We don't wrap .d files in %W{} since a missing .d file, and
865
   therefore no dependency entry, confuses make into thinking a .o
866
   file that happens to exist is up-to-date.  */
867
static const char *cpp_unique_options =
868
"%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
869
 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
870
 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
871
 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
872
 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
873
 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
874
 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
875
 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
876
 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
877
 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
878
 %{E|M|MM:%W{o*}}";
879
 
880
/* This contains cpp options which are common with cc1_options and are passed
881
   only when preprocessing only to avoid duplication.  We pass the cc1 spec
882
   options to the preprocessor so that it the cc1 spec may manipulate
883
   options used to set target flags.  Those special target flags settings may
884
   in turn cause preprocessor symbols to be defined specially.  */
885
static const char *cpp_options =
886
"%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
887
 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
888
 %{undef} %{save-temps*:-fpch-preprocess}";
889
 
890
/* This contains cpp options which are not passed when the preprocessor
891
   output will be used by another program.  */
892
static const char *cpp_debug_options = "%{d*}";
893
 
894
/* NB: This is shared amongst all front-ends, except for Ada.  */
895
static const char *cc1_options =
896
"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
897
 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{a*}\
898
 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
899
 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
900
 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
901
 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
902
 %{Qn:-fno-ident} %{--help:--help}\
903
 %{--target-help:--target-help}\
904
 %{--help=*:--help=%(VALUE)}\
905
 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
906
 %{fsyntax-only:-o %j} %{-param*}\
907
 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
908
 %{coverage:-fprofile-arcs -ftest-coverage}";
909
 
910
static const char *asm_options =
911
"%{--target-help:%:print-asm-header()} "
912
#if HAVE_GNU_AS
913
/* If GNU AS is used, then convert -w (no warnings), -I, and -v
914
   to the assembler equivalents.  */
915
"%{v} %{w:-W} %{I*} "
916
#endif
917
"%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
918
 
919
static const char *invoke_as =
920
#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
921
"%{!fwpa:\
922
   %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
923
   %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
924
  }";
925
#else
926
"%{!fwpa:\
927
   %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
928
   %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
929
  }";
930
#endif
931
 
932
/* Some compilers have limits on line lengths, and the multilib_select
933
   and/or multilib_matches strings can be very long, so we build them at
934
   run time.  */
935
static struct obstack multilib_obstack;
936
static const char *multilib_select;
937
static const char *multilib_matches;
938
static const char *multilib_defaults;
939
static const char *multilib_exclusions;
940
 
941
/* Check whether a particular argument is a default argument.  */
942
 
943
#ifndef MULTILIB_DEFAULTS
944
#define MULTILIB_DEFAULTS { "" }
945
#endif
946
 
947
static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
948
 
949
#ifndef DRIVER_SELF_SPECS
950
#define DRIVER_SELF_SPECS ""
951
#endif
952
 
953
/* Adding -fopenmp should imply pthreads.  This is particularly important
954
   for targets that use different start files and suchlike.  */
955
#ifndef GOMP_SELF_SPECS
956
#define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
957
#endif
958
 
959
static const char *const driver_self_specs[] = {
960
  "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
961
  DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS
962
};
963
 
964
#ifndef OPTION_DEFAULT_SPECS
965
#define OPTION_DEFAULT_SPECS { "", "" }
966
#endif
967
 
968
struct default_spec
969
{
970
  const char *name;
971
  const char *spec;
972
};
973
 
974
static const struct default_spec
975
  option_default_specs[] = { OPTION_DEFAULT_SPECS };
976
 
977
struct user_specs
978
{
979
  struct user_specs *next;
980
  const char *filename;
981
};
982
 
983
static struct user_specs *user_specs_head, *user_specs_tail;
984
 
985
#ifndef SWITCH_TAKES_ARG
986
#define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
987
#endif
988
 
989
#ifndef WORD_SWITCH_TAKES_ARG
990
#define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
991
#endif
992
 
993
#ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
994
/* This defines which switches stop a full compilation.  */
995
#define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
996
  ((CHAR) == 'c' || (CHAR) == 'S' || (CHAR) == 'E')
997
 
998
#ifndef SWITCH_CURTAILS_COMPILATION
999
#define SWITCH_CURTAILS_COMPILATION(CHAR) \
1000
  DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
1001
#endif
1002
#endif
1003
 
1004
/* Record the mapping from file suffixes for compilation specs.  */
1005
 
1006
struct compiler
1007
{
1008
  const char *suffix;           /* Use this compiler for input files
1009
                                   whose names end in this suffix.  */
1010
 
1011
  const char *spec;             /* To use this compiler, run this spec.  */
1012
 
1013
  const char *cpp_spec;         /* If non-NULL, substitute this spec
1014
                                   for `%C', rather than the usual
1015
                                   cpp_spec.  */
1016
  const int combinable;          /* If nonzero, compiler can deal with
1017
                                    multiple source files at once (IMA).  */
1018
  const int needs_preprocessing; /* If nonzero, source files need to
1019
                                    be run through a preprocessor.  */
1020
};
1021
 
1022
/* Pointer to a vector of `struct compiler' that gives the spec for
1023
   compiling a file, based on its suffix.
1024
   A file that does not end in any of these suffixes will be passed
1025
   unchanged to the loader and nothing else will be done to it.
1026
 
1027
   An entry containing two 0s is used to terminate the vector.
1028
 
1029
   If multiple entries match a file, the last matching one is used.  */
1030
 
1031
static struct compiler *compilers;
1032
 
1033
/* Number of entries in `compilers', not counting the null terminator.  */
1034
 
1035
static int n_compilers;
1036
 
1037
/* The default list of file name suffixes and their compilation specs.  */
1038
 
1039
static const struct compiler default_compilers[] =
1040
{
1041
  /* Add lists of suffixes of known languages here.  If those languages
1042
     were not present when we built the driver, we will hit these copies
1043
     and be given a more meaningful error than "file not used since
1044
     linking is not done".  */
1045
  {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
1046
  {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1047
  {".mii", "#Objective-C++", 0, 0, 0},
1048
  {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1049
  {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1050
  {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1051
  {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1052
  {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1053
  {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1054
  {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1055
  {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1056
  {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1057
  {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1058
  {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1059
  {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1060
  {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1061
  {".r", "#Ratfor", 0, 0, 0},
1062
  {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1063
  {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1064
  {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1065
  /* Next come the entries for C.  */
1066
  {".c", "@c", 0, 1, 1},
1067
  {"@c",
1068
   /* cc1 has an integrated ISO C preprocessor.  We should invoke the
1069
      external preprocessor if -save-temps is given.  */
1070
     "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1071
      %{!E:%{!M:%{!MM:\
1072
          %{traditional|ftraditional:\
1073
%eGNU C no longer supports -traditional without -E}\
1074
       %{!combine:\
1075
          %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1076
                %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1077
                    cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1078
                        %(cc1_options)}\
1079
          %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1080
                cc1 %(cpp_unique_options) %(cc1_options)}}}\
1081
          %{!fsyntax-only:%(invoke_as)}} \
1082
      %{combine:\
1083
          %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1084
                %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i}}\
1085
          %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1086
                cc1 %(cpp_unique_options) %(cc1_options)}}\
1087
                %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
1088
  {"-",
1089
   "%{!E:%e-E or -x required when input is from standard input}\
1090
    %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1091
  {".h", "@c-header", 0, 0, 0},
1092
  {"@c-header",
1093
   /* cc1 has an integrated ISO C preprocessor.  We should invoke the
1094
      external preprocessor if -save-temps is given.  */
1095
     "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1096
      %{!E:%{!M:%{!MM:\
1097
          %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1098
                %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1099
                    cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1100
                        %(cc1_options)\
1101
                        -o %g.s %{!o*:--output-pch=%i.gch}\
1102
                        %W{o*:--output-pch=%*}%V}\
1103
          %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1104
                cc1 %(cpp_unique_options) %(cc1_options)\
1105
                    -o %g.s %{!o*:--output-pch=%i.gch}\
1106
                    %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
1107
  {".i", "@cpp-output", 0, 1, 0},
1108
  {"@cpp-output",
1109
   "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
1110
  {".s", "@assembler", 0, 1, 0},
1111
  {"@assembler",
1112
   "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
1113
  {".sx", "@assembler-with-cpp", 0, 1, 0},
1114
  {".S", "@assembler-with-cpp", 0, 1, 0},
1115
  {"@assembler-with-cpp",
1116
#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1117
   "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1118
      %{E|M|MM:%(cpp_debug_options)}\
1119
      %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1120
       as %(asm_debug) %(asm_options) %|.s %A }}}}"
1121
#else
1122
   "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1123
      %{E|M|MM:%(cpp_debug_options)}\
1124
      %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1125
       as %(asm_debug) %(asm_options) %m.s %A }}}}"
1126
#endif
1127
   , 0, 1, 0},
1128
 
1129
#include "specs.h"
1130
  /* Mark end of table.  */
1131
  {0, 0, 0, 0, 0}
1132
};
1133
 
1134
/* Number of elements in default_compilers, not counting the terminator.  */
1135
 
1136
static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1137
 
1138
/* A vector of options to give to the linker.
1139
   These options are accumulated by %x,
1140
   and substituted into the linker command with %X.  */
1141
static int n_linker_options;
1142
static char **linker_options;
1143
 
1144
/* A vector of options to give to the assembler.
1145
   These options are accumulated by -Wa,
1146
   and substituted into the assembler command with %Y.  */
1147
static int n_assembler_options;
1148
static char **assembler_options;
1149
 
1150
/* A vector of options to give to the preprocessor.
1151
   These options are accumulated by -Wp,
1152
   and substituted into the preprocessor command with %Z.  */
1153
static int n_preprocessor_options;
1154
static char **preprocessor_options;
1155
 
1156
/* Define how to map long options into short ones.  */
1157
 
1158
/* This structure describes one mapping.  */
1159
struct option_map
1160
{
1161
  /* The long option's name.  */
1162
  const char *const name;
1163
  /* The equivalent short option.  */
1164
  const char *const equivalent;
1165
  /* Argument info.  A string of flag chars; NULL equals no options.
1166
     a => argument required.
1167
     o => argument optional.
1168
     j => join argument to equivalent, making one word.
1169
     * => require other text after NAME as an argument.  */
1170
  const char *const arg_info;
1171
};
1172
 
1173
/* This is the table of mappings.  Mappings are tried sequentially
1174
   for each option encountered; the first one that matches, wins.  */
1175
 
1176
static const struct option_map option_map[] =
1177
 {
1178
   {"--all-warnings", "-Wall", 0},
1179
   {"--ansi", "-ansi", 0},
1180
   {"--assemble", "-S", 0},
1181
   {"--assert", "-A", "a"},
1182
   {"--classpath", "-fclasspath=", "aj"},
1183
   {"--bootclasspath", "-fbootclasspath=", "aj"},
1184
   {"--CLASSPATH", "-fclasspath=", "aj"},
1185
   {"--combine", "-combine", 0},
1186
   {"--comments", "-C", 0},
1187
   {"--comments-in-macros", "-CC", 0},
1188
   {"--compile", "-c", 0},
1189
   {"--debug", "-g", "oj"},
1190
   {"--define-macro", "-D", "aj"},
1191
   {"--dependencies", "-M", 0},
1192
   {"--dump", "-d", "a"},
1193
   {"--dumpbase", "-dumpbase", "a"},
1194
   {"--dumpdir", "-dumpdir", "a"},
1195
   {"--encoding", "-fencoding=", "aj"},
1196
   {"--entry", "-e", 0},
1197
   {"--extra-warnings", "-W", 0},
1198
   {"--extdirs", "-fextdirs=", "aj"},
1199
   {"--for-assembler", "-Wa", "a"},
1200
   {"--for-linker", "-Xlinker", "a"},
1201
   {"--force-link", "-u", "a"},
1202
   {"--coverage", "-coverage", 0},
1203
   {"--imacros", "-imacros", "a"},
1204
   {"--include", "-include", "a"},
1205
   {"--include-barrier", "-I-", 0},
1206
   {"--include-directory", "-I", "aj"},
1207
   {"--include-directory-after", "-idirafter", "a"},
1208
   {"--include-prefix", "-iprefix", "a"},
1209
   {"--include-with-prefix", "-iwithprefix", "a"},
1210
   {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1211
   {"--include-with-prefix-after", "-iwithprefix", "a"},
1212
   {"--language", "-x", "a"},
1213
   {"--library-directory", "-L", "a"},
1214
   {"--machine", "-m", "aj"},
1215
   {"--machine-", "-m", "*j"},
1216
   {"--no-canonical-prefixes", "-no-canonical-prefixes", 0},
1217
   {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1218
   {"--no-line-commands", "-P", 0},
1219
   {"--no-precompiled-includes", "-noprecomp", 0},
1220
   {"--no-standard-includes", "-nostdinc", 0},
1221
   {"--no-standard-libraries", "-nostdlib", 0},
1222
   {"--no-warnings", "-w", 0},
1223
   {"--optimize", "-O", "oj"},
1224
   {"--output", "-o", "a"},
1225
   {"--output-class-directory", "-foutput-class-dir=", "ja"},
1226
   {"--param", "--param", "a"},
1227
   {"--pass-exit-codes", "-pass-exit-codes", 0},
1228
   {"--pedantic", "-pedantic", 0},
1229
   {"--pedantic-errors", "-pedantic-errors", 0},
1230
   {"--pie", "-pie", 0},
1231
   {"--pipe", "-pipe", 0},
1232
   {"--prefix", "-B", "a"},
1233
   {"--preprocess", "-E", 0},
1234
   {"--print-search-dirs", "-print-search-dirs", 0},
1235
   {"--print-file-name", "-print-file-name=", "aj"},
1236
   {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1237
   {"--print-missing-file-dependencies", "-MG", 0},
1238
   {"--print-multi-lib", "-print-multi-lib", 0},
1239
   {"--print-multi-directory", "-print-multi-directory", 0},
1240
   {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1241
   {"--print-prog-name", "-print-prog-name=", "aj"},
1242
   {"--print-sysroot", "-print-sysroot", 0},
1243
   {"--print-sysroot-headers-suffix", "-print-sysroot-headers-suffix", 0},
1244
   {"--profile", "-p", 0},
1245
   {"--profile-blocks", "-a", 0},
1246
   {"--quiet", "-q", 0},
1247
   {"--resource", "-fcompile-resource=", "aj"},
1248
   {"--save-temps", "-save-temps", 0},
1249
   {"--shared", "-shared", 0},
1250
   {"--silent", "-q", 0},
1251
   {"--specs", "-specs=", "aj"},
1252
   {"--static", "-static", 0},
1253
   {"--std", "-std=", "aj"},
1254
   {"--symbolic", "-symbolic", 0},
1255
   {"--sysroot", "--sysroot=", "aj"},
1256
   {"--time", "-time", 0},
1257
   {"--trace-includes", "-H", 0},
1258
   {"--traditional", "-traditional", 0},
1259
   {"--traditional-cpp", "-traditional-cpp", 0},
1260
   {"--trigraphs", "-trigraphs", 0},
1261
   {"--undefine-macro", "-U", "aj"},
1262
   {"--user-dependencies", "-MM", 0},
1263
   {"--verbose", "-v", 0},
1264
   {"--warn-", "-W", "*j"},
1265
   {"--write-dependencies", "-MD", 0},
1266
   {"--write-user-dependencies", "-MMD", 0},
1267
   {"--", "-f", "*j"}
1268
 };
1269
 
1270
 
1271
#ifdef TARGET_OPTION_TRANSLATE_TABLE
1272
static const struct {
1273
  const char *const option_found;
1274
  const char *const replacements;
1275
} target_option_translations[] =
1276
{
1277
  TARGET_OPTION_TRANSLATE_TABLE,
1278
  { 0, 0 }
1279
};
1280
#endif
1281
 
1282
/* Translate the options described by *ARGCP and *ARGVP.
1283
   Make a new vector and store it back in *ARGVP,
1284
   and store its length in *ARGCP.  */
1285
 
1286
static void
1287
translate_options (int *argcp, const char *const **argvp)
1288
{
1289
  int i;
1290
  int argc = *argcp;
1291
  const char *const *argv = *argvp;
1292
  int newvsize = (argc + 2) * 2 * sizeof (const char *);
1293
  const char **newv = XNEWVAR (const char *, newvsize);
1294
  int newindex = 0;
1295
 
1296
  i = 0;
1297
  newv[newindex++] = argv[i++];
1298
 
1299
  while (i < argc)
1300
    {
1301
#ifdef TARGET_OPTION_TRANSLATE_TABLE
1302
      int tott_idx;
1303
 
1304
      for (tott_idx = 0;
1305
           target_option_translations[tott_idx].option_found;
1306
           tott_idx++)
1307
        {
1308
          if (strcmp (target_option_translations[tott_idx].option_found,
1309
                      argv[i]) == 0)
1310
            {
1311
              int spaces = 1;
1312
              const char *sp;
1313
              char *np;
1314
 
1315
              for (sp = target_option_translations[tott_idx].replacements;
1316
                   *sp; sp++)
1317
                {
1318
                  if (*sp == ' ')
1319
                    spaces ++;
1320
                }
1321
 
1322
              newvsize += spaces * sizeof (const char *);
1323
              newv =  XRESIZEVAR (const char *, newv, newvsize);
1324
 
1325
              sp = target_option_translations[tott_idx].replacements;
1326
              np = xstrdup (sp);
1327
 
1328
              while (1)
1329
                {
1330
                  while (*np == ' ')
1331
                    np++;
1332
                  if (*np == 0)
1333
                    break;
1334
                  newv[newindex++] = np;
1335
                  while (*np != ' ' && *np)
1336
                    np++;
1337
                  if (*np == 0)
1338
                    break;
1339
                  *np++ = 0;
1340
                }
1341
 
1342
              i ++;
1343
              break;
1344
            }
1345
        }
1346
      if (target_option_translations[tott_idx].option_found)
1347
        continue;
1348
#endif
1349
 
1350
      /* Translate -- options.  */
1351
      if (argv[i][0] == '-' && argv[i][1] == '-')
1352
        {
1353
          size_t j;
1354
          /* Find a mapping that applies to this option.  */
1355
          for (j = 0; j < ARRAY_SIZE (option_map); j++)
1356
            {
1357
              size_t optlen = strlen (option_map[j].name);
1358
              size_t arglen = strlen (argv[i]);
1359
              size_t complen = arglen > optlen ? optlen : arglen;
1360
              const char *arginfo = option_map[j].arg_info;
1361
 
1362
              if (arginfo == 0)
1363
                arginfo = "";
1364
 
1365
              if (!strncmp (argv[i], option_map[j].name, complen))
1366
                {
1367
                  const char *arg = 0;
1368
 
1369
                  if (arglen < optlen)
1370
                    {
1371
                      size_t k;
1372
                      for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1373
                        if (strlen (option_map[k].name) >= arglen
1374
                            && !strncmp (argv[i], option_map[k].name, arglen))
1375
                          {
1376
                            error ("ambiguous abbreviation %s", argv[i]);
1377
                            break;
1378
                          }
1379
 
1380
                      if (k != ARRAY_SIZE (option_map))
1381
                        break;
1382
                    }
1383
 
1384
                  if (arglen > optlen)
1385
                    {
1386
                      /* If the option has an argument, accept that.  */
1387
                      if (argv[i][optlen] == '=')
1388
                        arg = argv[i] + optlen + 1;
1389
 
1390
                      /* If this mapping requires extra text at end of name,
1391
                         accept that as "argument".  */
1392
                      else if (strchr (arginfo, '*') != 0)
1393
                        arg = argv[i] + optlen;
1394
 
1395
                      /* Otherwise, extra text at end means mismatch.
1396
                         Try other mappings.  */
1397
                      else
1398
                        continue;
1399
                    }
1400
 
1401
                  else if (strchr (arginfo, '*') != 0)
1402
                    {
1403
                      error ("incomplete '%s' option", option_map[j].name);
1404
                      break;
1405
                    }
1406
 
1407
                  /* Handle arguments.  */
1408
                  if (strchr (arginfo, 'a') != 0)
1409
                    {
1410
                      if (arg == 0)
1411
                        {
1412
                          if (i + 1 == argc)
1413
                            {
1414
                              error ("missing argument to '%s' option",
1415
                                     option_map[j].name);
1416
                              break;
1417
                            }
1418
 
1419
                          arg = argv[++i];
1420
                        }
1421
                    }
1422
                  else if (strchr (arginfo, '*') != 0)
1423
                    ;
1424
                  else if (strchr (arginfo, 'o') == 0)
1425
                    {
1426
                      if (arg != 0)
1427
                        error ("extraneous argument to '%s' option",
1428
                               option_map[j].name);
1429
                      arg = 0;
1430
                    }
1431
 
1432
                  /* Store the translation as one argv elt or as two.  */
1433
                  if (arg != 0 && strchr (arginfo, 'j') != 0)
1434
                    newv[newindex++] = concat (option_map[j].equivalent, arg,
1435
                                               NULL);
1436
                  else if (arg != 0)
1437
                    {
1438
                      newv[newindex++] = option_map[j].equivalent;
1439
                      newv[newindex++] = arg;
1440
                    }
1441
                  else
1442
                    newv[newindex++] = option_map[j].equivalent;
1443
 
1444
                  break;
1445
                }
1446
            }
1447
          i++;
1448
        }
1449
 
1450
      /* Handle old-fashioned options--just copy them through,
1451
         with their arguments.  */
1452
      else if (argv[i][0] == '-')
1453
        {
1454
          const char *p = argv[i] + 1;
1455
          int c = *p;
1456
          int nskip = 1;
1457
 
1458
          if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1459
            nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1460
          else if (WORD_SWITCH_TAKES_ARG (p))
1461
            nskip += WORD_SWITCH_TAKES_ARG (p);
1462
          else if ((c == 'B' || c == 'b' || c == 'x')
1463
                   && p[1] == 0)
1464
            nskip += 1;
1465
          else if (! strcmp (p, "Xlinker"))
1466
            nskip += 1;
1467
          else if (! strcmp (p, "Xpreprocessor"))
1468
            nskip += 1;
1469
          else if (! strcmp (p, "Xassembler"))
1470
            nskip += 1;
1471
 
1472
          /* Watch out for an option at the end of the command line that
1473
             is missing arguments, and avoid skipping past the end of the
1474
             command line.  */
1475
          if (nskip + i > argc)
1476
            nskip = argc - i;
1477
 
1478
          while (nskip > 0)
1479
            {
1480
              newv[newindex++] = argv[i++];
1481
              nskip--;
1482
            }
1483
        }
1484
      else
1485
        /* Ordinary operands, or +e options.  */
1486
        newv[newindex++] = argv[i++];
1487
    }
1488
 
1489
  newv[newindex] = 0;
1490
 
1491
  *argvp = newv;
1492
  *argcp = newindex;
1493
}
1494
 
1495
static char *
1496
skip_whitespace (char *p)
1497
{
1498
  while (1)
1499
    {
1500
      /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1501
         be considered whitespace.  */
1502
      if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1503
        return p + 1;
1504
      else if (*p == '\n' || *p == ' ' || *p == '\t')
1505
        p++;
1506
      else if (*p == '#')
1507
        {
1508
          while (*p != '\n')
1509
            p++;
1510
          p++;
1511
        }
1512
      else
1513
        break;
1514
    }
1515
 
1516
  return p;
1517
}
1518
/* Structures to keep track of prefixes to try when looking for files.  */
1519
 
1520
struct prefix_list
1521
{
1522
  const char *prefix;         /* String to prepend to the path.  */
1523
  struct prefix_list *next;   /* Next in linked list.  */
1524
  int require_machine_suffix; /* Don't use without machine_suffix.  */
1525
  /* 2 means try both machine_suffix and just_machine_suffix.  */
1526
  int priority;               /* Sort key - priority within list.  */
1527
  int os_multilib;            /* 1 if OS multilib scheme should be used,
1528
 
1529
};
1530
 
1531
struct path_prefix
1532
{
1533
  struct prefix_list *plist;  /* List of prefixes to try */
1534
  int max_len;                /* Max length of a prefix in PLIST */
1535
  const char *name;           /* Name of this list (used in config stuff) */
1536
};
1537
 
1538
/* List of prefixes to try when looking for executables.  */
1539
 
1540
static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1541
 
1542
/* List of prefixes to try when looking for startup (crt0) files.  */
1543
 
1544
static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1545
 
1546
/* List of prefixes to try when looking for include files.  */
1547
 
1548
static struct path_prefix include_prefixes = { 0, 0, "include" };
1549
 
1550
/* Suffix to attach to directories searched for commands.
1551
   This looks like `MACHINE/VERSION/'.  */
1552
 
1553
static const char *machine_suffix = 0;
1554
 
1555
/* Suffix to attach to directories searched for commands.
1556
   This is just `MACHINE/'.  */
1557
 
1558
static const char *just_machine_suffix = 0;
1559
 
1560
/* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1561
 
1562
static const char *gcc_exec_prefix;
1563
 
1564
/* Adjusted value of standard_libexec_prefix.  */
1565
 
1566
static const char *gcc_libexec_prefix;
1567
 
1568
/* Default prefixes to attach to command names.  */
1569
 
1570
#ifndef STANDARD_STARTFILE_PREFIX_1
1571
#define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1572
#endif
1573
#ifndef STANDARD_STARTFILE_PREFIX_2
1574
#define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1575
#endif
1576
 
1577
#ifdef CROSS_DIRECTORY_STRUCTURE  /* Don't use these prefixes for a cross compiler.  */
1578
#undef MD_EXEC_PREFIX
1579
#undef MD_STARTFILE_PREFIX
1580
#undef MD_STARTFILE_PREFIX_1
1581
#endif
1582
 
1583
/* If no prefixes defined, use the null string, which will disable them.  */
1584
#ifndef MD_EXEC_PREFIX
1585
#define MD_EXEC_PREFIX ""
1586
#endif
1587
#ifndef MD_STARTFILE_PREFIX
1588
#define MD_STARTFILE_PREFIX ""
1589
#endif
1590
#ifndef MD_STARTFILE_PREFIX_1
1591
#define MD_STARTFILE_PREFIX_1 ""
1592
#endif
1593
 
1594
/* These directories are locations set at configure-time based on the
1595
   --prefix option provided to configure.  Their initializers are
1596
   defined in Makefile.in.  These paths are not *directly* used when
1597
   gcc_exec_prefix is set because, in that case, we know where the
1598
   compiler has been installed, and use paths relative to that
1599
   location instead.  */
1600
static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1601
static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1602
static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1603
static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1604
 
1605
/* For native compilers, these are well-known paths containing
1606
   components that may be provided by the system.  For cross
1607
   compilers, these paths are not used.  */
1608
static const char *md_exec_prefix = MD_EXEC_PREFIX;
1609
static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1610
static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1611
static const char *const standard_startfile_prefix_1
1612
  = STANDARD_STARTFILE_PREFIX_1;
1613
static const char *const standard_startfile_prefix_2
1614
  = STANDARD_STARTFILE_PREFIX_2;
1615
 
1616
/* A relative path to be used in finding the location of tools
1617
   relative to the driver.  */
1618
static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1619
 
1620
/* Subdirectory to use for locating libraries.  Set by
1621
   set_multilib_dir based on the compilation options.  */
1622
 
1623
static const char *multilib_dir;
1624
 
1625
/* Subdirectory to use for locating libraries in OS conventions.  Set by
1626
   set_multilib_dir based on the compilation options.  */
1627
 
1628
static const char *multilib_os_dir;
1629
 
1630
/* Structure to keep track of the specs that have been defined so far.
1631
   These are accessed using %(specname) or %[specname] in a compiler
1632
   or link spec.  */
1633
 
1634
struct spec_list
1635
{
1636
                                /* The following 2 fields must be first */
1637
                                /* to allow EXTRA_SPECS to be initialized */
1638
  const char *name;             /* name of the spec.  */
1639
  const char *ptr;              /* available ptr if no static pointer */
1640
 
1641
                                /* The following fields are not initialized */
1642
                                /* by EXTRA_SPECS */
1643
  const char **ptr_spec;        /* pointer to the spec itself.  */
1644
  struct spec_list *next;       /* Next spec in linked list.  */
1645
  int name_len;                 /* length of the name */
1646
  int alloc_p;                  /* whether string was allocated */
1647
};
1648
 
1649
#define INIT_STATIC_SPEC(NAME,PTR) \
1650
{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1651
 
1652
/* List of statically defined specs.  */
1653
static struct spec_list static_specs[] =
1654
{
1655
  INIT_STATIC_SPEC ("asm",                      &asm_spec),
1656
  INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1657
  INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1658
  INIT_STATIC_SPEC ("asm_options",              &asm_options),
1659
  INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1660
  INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1661
  INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1662
  INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1663
  INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1664
  INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1665
  INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1666
  INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1667
  INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1668
  INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1669
  INIT_STATIC_SPEC ("link_ssp",                 &link_ssp_spec),
1670
  INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1671
  INIT_STATIC_SPEC ("link",                     &link_spec),
1672
  INIT_STATIC_SPEC ("lib",                      &lib_spec),
1673
  INIT_STATIC_SPEC ("mfwrap",                   &mfwrap_spec),
1674
  INIT_STATIC_SPEC ("mflib",                    &mflib_spec),
1675
  INIT_STATIC_SPEC ("link_gomp",                &link_gomp_spec),
1676
  INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1677
  INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1678
  INIT_STATIC_SPEC ("switches_need_spaces",     &switches_need_spaces),
1679
  INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1680
  INIT_STATIC_SPEC ("version",                  &compiler_version),
1681
  INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1682
  INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1683
  INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1684
  INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1685
  INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1686
  INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1687
  INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1688
  INIT_STATIC_SPEC ("linker_plugin_file",       &linker_plugin_file_spec),
1689
  INIT_STATIC_SPEC ("lto_wrapper",              &lto_wrapper_spec),
1690
  INIT_STATIC_SPEC ("lto_gcc",                  &lto_gcc_spec),
1691
  INIT_STATIC_SPEC ("lto_libgcc",               &lto_libgcc_spec),
1692
  INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1693
  INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1694
  INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1695
  INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1696
  INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1697
  INIT_STATIC_SPEC ("sysroot_spec",             &sysroot_spec),
1698
  INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1699
  INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1700
};
1701
 
1702
#ifdef EXTRA_SPECS              /* additional specs needed */
1703
/* Structure to keep track of just the first two args of a spec_list.
1704
   That is all that the EXTRA_SPECS macro gives us.  */
1705
struct spec_list_1
1706
{
1707
  const char *const name;
1708
  const char *const ptr;
1709
};
1710
 
1711
static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1712
static struct spec_list *extra_specs = (struct spec_list *) 0;
1713
#endif
1714
 
1715
/* List of dynamically allocates specs that have been defined so far.  */
1716
 
1717
static struct spec_list *specs = (struct spec_list *) 0;
1718
 
1719
/* List of static spec functions.  */
1720
 
1721
static const struct spec_function static_spec_functions[] =
1722
{
1723
  { "getenv",                   getenv_spec_function },
1724
  { "if-exists",                if_exists_spec_function },
1725
  { "if-exists-else",           if_exists_else_spec_function },
1726
  { "replace-outfile",          replace_outfile_spec_function },
1727
  { "version-compare",          version_compare_spec_function },
1728
  { "include",                  include_spec_function },
1729
  { "print-asm-header",         print_asm_header_spec_function },
1730
  { "compare-debug-dump-opt",   compare_debug_dump_opt_spec_function },
1731
  { "compare-debug-self-opt",   compare_debug_self_opt_spec_function },
1732
  { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1733
#ifdef EXTRA_SPEC_FUNCTIONS
1734
  EXTRA_SPEC_FUNCTIONS
1735
#endif
1736
  { 0, 0 }
1737
};
1738
 
1739
static int processing_spec_function;
1740
 
1741
/* Add appropriate libgcc specs to OBSTACK, taking into account
1742
   various permutations of -shared-libgcc, -shared, and such.  */
1743
 
1744
#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1745
 
1746
#ifndef USE_LD_AS_NEEDED
1747
#define USE_LD_AS_NEEDED 0
1748
#endif
1749
 
1750
static void
1751
init_gcc_specs (struct obstack *obstack, const char *shared_name,
1752
                const char *static_name, const char *eh_name)
1753
{
1754
  char *buf;
1755
 
1756
  buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1757
                "%{!static:%{!static-libgcc:"
1758
#if USE_LD_AS_NEEDED
1759
                "%{!shared-libgcc:",
1760
                static_name, " --as-needed ", shared_name, " --no-as-needed"
1761
                "}"
1762
                "%{shared-libgcc:",
1763
                shared_name, "%{!shared: ", static_name, "}"
1764
                "}"
1765
#else
1766
                "%{!shared:"
1767
                "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1768
                "%{shared-libgcc:", shared_name, " ", static_name, "}"
1769
                "}"
1770
#ifdef LINK_EH_SPEC
1771
                "%{shared:"
1772
                "%{shared-libgcc:", shared_name, "}"
1773
                "%{!shared-libgcc:", static_name, "}"
1774
                "}"
1775
#else
1776
                "%{shared:", shared_name, "}"
1777
#endif
1778
#endif
1779
                "}}", NULL);
1780
 
1781
  obstack_grow (obstack, buf, strlen (buf));
1782
  free (buf);
1783
}
1784
#endif /* ENABLE_SHARED_LIBGCC */
1785
 
1786
/* Initialize the specs lookup routines.  */
1787
 
1788
static void
1789
init_spec (void)
1790
{
1791
  struct spec_list *next = (struct spec_list *) 0;
1792
  struct spec_list *sl   = (struct spec_list *) 0;
1793
  int i;
1794
 
1795
  if (specs)
1796
    return;                     /* Already initialized.  */
1797
 
1798
  if (verbose_flag)
1799
    notice ("Using built-in specs.\n");
1800
 
1801
#ifdef EXTRA_SPECS
1802
  extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1803
 
1804
  for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1805
    {
1806
      sl = &extra_specs[i];
1807
      sl->name = extra_specs_1[i].name;
1808
      sl->ptr = extra_specs_1[i].ptr;
1809
      sl->next = next;
1810
      sl->name_len = strlen (sl->name);
1811
      sl->ptr_spec = &sl->ptr;
1812
      next = sl;
1813
    }
1814
#endif
1815
 
1816
  for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1817
    {
1818
      sl = &static_specs[i];
1819
      sl->next = next;
1820
      next = sl;
1821
    }
1822
 
1823
#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1824
  /* ??? If neither -shared-libgcc nor --static-libgcc was
1825
     seen, then we should be making an educated guess.  Some proposed
1826
     heuristics for ELF include:
1827
 
1828
        (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1829
            program will be doing dynamic loading, which will likely
1830
            need the shared libgcc.
1831
 
1832
        (2) If "-ldl", then it's also a fair bet that we're doing
1833
            dynamic loading.
1834
 
1835
        (3) For each ET_DYN we're linking against (either through -lfoo
1836
            or /some/path/foo.so), check to see whether it or one of
1837
            its dependencies depends on a shared libgcc.
1838
 
1839
        (4) If "-shared"
1840
 
1841
            If the runtime is fixed to look for program headers instead
1842
            of calling __register_frame_info at all, for each object,
1843
            use the shared libgcc if any EH symbol referenced.
1844
 
1845
            If crtstuff is fixed to not invoke __register_frame_info
1846
            automatically, for each object, use the shared libgcc if
1847
            any non-empty unwind section found.
1848
 
1849
     Doing any of this probably requires invoking an external program to
1850
     do the actual object file scanning.  */
1851
  {
1852
    const char *p = libgcc_spec;
1853
    int in_sep = 1;
1854
 
1855
    /* Transform the extant libgcc_spec into one that uses the shared libgcc
1856
       when given the proper command line arguments.  */
1857
    while (*p)
1858
      {
1859
        if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1860
          {
1861
            init_gcc_specs (&obstack,
1862
                            "-lgcc_s"
1863
#ifdef USE_LIBUNWIND_EXCEPTIONS
1864
                            " -lunwind"
1865
#endif
1866
                            ,
1867
                            "-lgcc",
1868
                            "-lgcc_eh"
1869
#ifdef USE_LIBUNWIND_EXCEPTIONS
1870
# ifdef HAVE_LD_STATIC_DYNAMIC
1871
                            " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1872
# else
1873
                            " -lunwind"
1874
# endif
1875
#endif
1876
                            );
1877
 
1878
            p += 5;
1879
            in_sep = 0;
1880
          }
1881
        else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1882
          {
1883
            /* Ug.  We don't know shared library extensions.  Hope that
1884
               systems that use this form don't do shared libraries.  */
1885
            init_gcc_specs (&obstack,
1886
                            "-lgcc_s",
1887
                            "libgcc.a%s",
1888
                            "libgcc_eh.a%s"
1889
#ifdef USE_LIBUNWIND_EXCEPTIONS
1890
                            " -lunwind"
1891
#endif
1892
                            );
1893
            p += 10;
1894
            in_sep = 0;
1895
          }
1896
        else
1897
          {
1898
            obstack_1grow (&obstack, *p);
1899
            in_sep = (*p == ' ');
1900
            p += 1;
1901
          }
1902
      }
1903
 
1904
    obstack_1grow (&obstack, '\0');
1905
    libgcc_spec = XOBFINISH (&obstack, const char *);
1906
  }
1907
#endif
1908
#ifdef USE_AS_TRADITIONAL_FORMAT
1909
  /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1910
  {
1911
    static const char tf[] = "--traditional-format ";
1912
    obstack_grow (&obstack, tf, sizeof(tf) - 1);
1913
    obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1914
    asm_spec = XOBFINISH (&obstack, const char *);
1915
  }
1916
#endif
1917
 
1918
#if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1919
# ifdef LINK_BUILDID_SPEC
1920
  /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before.  */
1921
  obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1922
# endif
1923
# ifdef LINK_EH_SPEC
1924
  /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1925
  obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1926
# endif
1927
  obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1928
  link_spec = XOBFINISH (&obstack, const char *);
1929
#endif
1930
 
1931
  specs = sl;
1932
}
1933
 
1934
/* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1935
   removed; If the spec starts with a + then SPEC is added to the end of the
1936
   current spec.  */
1937
 
1938
static void
1939
set_spec (const char *name, const char *spec)
1940
{
1941
  struct spec_list *sl;
1942
  const char *old_spec;
1943
  int name_len = strlen (name);
1944
  int i;
1945
 
1946
  /* If this is the first call, initialize the statically allocated specs.  */
1947
  if (!specs)
1948
    {
1949
      struct spec_list *next = (struct spec_list *) 0;
1950
      for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1951
        {
1952
          sl = &static_specs[i];
1953
          sl->next = next;
1954
          next = sl;
1955
        }
1956
      specs = sl;
1957
    }
1958
 
1959
  /* See if the spec already exists.  */
1960
  for (sl = specs; sl; sl = sl->next)
1961
    if (name_len == sl->name_len && !strcmp (sl->name, name))
1962
      break;
1963
 
1964
  if (!sl)
1965
    {
1966
      /* Not found - make it.  */
1967
      sl = XNEW (struct spec_list);
1968
      sl->name = xstrdup (name);
1969
      sl->name_len = name_len;
1970
      sl->ptr_spec = &sl->ptr;
1971
      sl->alloc_p = 0;
1972
      *(sl->ptr_spec) = "";
1973
      sl->next = specs;
1974
      specs = sl;
1975
    }
1976
 
1977
  old_spec = *(sl->ptr_spec);
1978
  *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1979
                     ? concat (old_spec, spec + 1, NULL)
1980
                     : xstrdup (spec));
1981
 
1982
#ifdef DEBUG_SPECS
1983
  if (verbose_flag)
1984
    notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1985
#endif
1986
 
1987
  /* Free the old spec.  */
1988
  if (old_spec && sl->alloc_p)
1989
    free (CONST_CAST(char *, old_spec));
1990
 
1991
  sl->alloc_p = 1;
1992
}
1993
 
1994
/* Accumulate a command (program name and args), and run it.  */
1995
 
1996
/* Vector of pointers to arguments in the current line of specifications.  */
1997
 
1998
static const char **argbuf;
1999
 
2000
/* Number of elements allocated in argbuf.  */
2001
 
2002
static int argbuf_length;
2003
 
2004
/* Number of elements in argbuf currently in use (containing args).  */
2005
 
2006
static int argbuf_index;
2007
 
2008
/* Position in the argbuf array containing the name of the output file
2009
   (the value associated with the "-o" flag).  */
2010
 
2011
static int have_o_argbuf_index = 0;
2012
 
2013
/* Were the options -c, -S or -E passed.  */
2014
static int have_c = 0;
2015
 
2016
/* Was the option -o passed.  */
2017
static int have_o = 0;
2018
 
2019
/* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2020
   temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
2021
   it here.  */
2022
 
2023
static struct temp_name {
2024
  const char *suffix;   /* suffix associated with the code.  */
2025
  int length;           /* strlen (suffix).  */
2026
  int unique;           /* Indicates whether %g or %u/%U was used.  */
2027
  const char *filename; /* associated filename.  */
2028
  int filename_length;  /* strlen (filename).  */
2029
  struct temp_name *next;
2030
} *temp_names;
2031
 
2032
/* Number of commands executed so far.  */
2033
 
2034
static int execution_count;
2035
 
2036
/* Number of commands that exited with a signal.  */
2037
 
2038
static int signal_count;
2039
 
2040
/* Name with which this program was invoked.  */
2041
 
2042
static const char *programname;
2043
 
2044
/* Allocate the argument vector.  */
2045
 
2046
static void
2047
alloc_args (void)
2048
{
2049
  argbuf_length = 10;
2050
  argbuf = XNEWVEC (const char *, argbuf_length);
2051
}
2052
 
2053
/* Clear out the vector of arguments (after a command is executed).  */
2054
 
2055
static void
2056
clear_args (void)
2057
{
2058
  argbuf_index = 0;
2059
}
2060
 
2061
/* Add one argument to the vector at the end.
2062
   This is done when a space is seen or at the end of the line.
2063
   If DELETE_ALWAYS is nonzero, the arg is a filename
2064
    and the file should be deleted eventually.
2065
   If DELETE_FAILURE is nonzero, the arg is a filename
2066
    and the file should be deleted if this compilation fails.  */
2067
 
2068
static void
2069
store_arg (const char *arg, int delete_always, int delete_failure)
2070
{
2071
  if (argbuf_index + 1 == argbuf_length)
2072
    argbuf = XRESIZEVEC (const char *, argbuf, (argbuf_length *= 2));
2073
 
2074
  argbuf[argbuf_index++] = arg;
2075
  argbuf[argbuf_index] = 0;
2076
 
2077
  if (strcmp (arg, "-o") == 0)
2078
    have_o_argbuf_index = argbuf_index;
2079
  if (delete_always || delete_failure)
2080
    record_temp_file (arg, delete_always, delete_failure);
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
load_specs (const char *filename)
2089
{
2090
  int desc;
2091
  int readlen;
2092
  struct stat statbuf;
2093
  char *buffer;
2094
  char *buffer_p;
2095
  char *specs;
2096
  char *specs_p;
2097
 
2098
  if (verbose_flag)
2099
    notice ("Reading specs from %s\n", filename);
2100
 
2101
  /* Open and stat the file.  */
2102
  desc = open (filename, O_RDONLY, 0);
2103
  if (desc < 0)
2104
    pfatal_with_name (filename);
2105
  if (stat (filename, &statbuf) < 0)
2106
    pfatal_with_name (filename);
2107
 
2108
  /* Read contents of file into BUFFER.  */
2109
  buffer = XNEWVEC (char, statbuf.st_size + 1);
2110
  readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2111
  if (readlen < 0)
2112
    pfatal_with_name (filename);
2113
  buffer[readlen] = 0;
2114
  close (desc);
2115
 
2116
  specs = XNEWVEC (char, readlen + 1);
2117
  specs_p = specs;
2118
  for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2119
    {
2120
      int skip = 0;
2121
      char c = *buffer_p;
2122
      if (c == '\r')
2123
        {
2124
          if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
2125
            skip = 1;
2126
          else if (*(buffer_p + 1) == '\n')                     /* \r\n */
2127
            skip = 1;
2128
          else                                                  /* \r */
2129
            c = '\n';
2130
        }
2131
      if (! skip)
2132
        *specs_p++ = c;
2133
    }
2134
  *specs_p = '\0';
2135
 
2136
  free (buffer);
2137
  return (specs);
2138
}
2139
 
2140
/* Read compilation specs from a file named FILENAME,
2141
   replacing the default ones.
2142
 
2143
   A suffix which starts with `*' is a definition for
2144
   one of the machine-specific sub-specs.  The "suffix" should be
2145
   *asm, *cc1, *cpp, *link, *startfile, etc.
2146
   The corresponding spec is stored in asm_spec, etc.,
2147
   rather than in the `compilers' vector.
2148
 
2149
   Anything invalid in the file is a fatal error.  */
2150
 
2151
static void
2152
read_specs (const char *filename, int main_p)
2153
{
2154
  char *buffer;
2155
  char *p;
2156
 
2157
  buffer = load_specs (filename);
2158
 
2159
  /* Scan BUFFER for specs, putting them in the vector.  */
2160
  p = buffer;
2161
  while (1)
2162
    {
2163
      char *suffix;
2164
      char *spec;
2165
      char *in, *out, *p1, *p2, *p3;
2166
 
2167
      /* Advance P in BUFFER to the next nonblank nocomment line.  */
2168
      p = skip_whitespace (p);
2169
      if (*p == 0)
2170
        break;
2171
 
2172
      /* Is this a special command that starts with '%'? */
2173
      /* Don't allow this for the main specs file, since it would
2174
         encourage people to overwrite it.  */
2175
      if (*p == '%' && !main_p)
2176
        {
2177
          p1 = p;
2178
          while (*p && *p != '\n')
2179
            p++;
2180
 
2181
          /* Skip '\n'.  */
2182
          p++;
2183
 
2184
          if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2185
              && (p1[sizeof "%include" - 1] == ' '
2186
                  || p1[sizeof "%include" - 1] == '\t'))
2187
            {
2188
              char *new_filename;
2189
 
2190
              p1 += sizeof ("%include");
2191
              while (*p1 == ' ' || *p1 == '\t')
2192
                p1++;
2193
 
2194
              if (*p1++ != '<' || p[-2] != '>')
2195
                fatal ("specs %%include syntax malformed after %ld characters",
2196
                       (long) (p1 - buffer + 1));
2197
 
2198
              p[-2] = '\0';
2199
              new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2200
              read_specs (new_filename ? new_filename : p1, FALSE);
2201
              continue;
2202
            }
2203
          else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2204
                   && (p1[sizeof "%include_noerr" - 1] == ' '
2205
                       || p1[sizeof "%include_noerr" - 1] == '\t'))
2206
            {
2207
              char *new_filename;
2208
 
2209
              p1 += sizeof "%include_noerr";
2210
              while (*p1 == ' ' || *p1 == '\t')
2211
                p1++;
2212
 
2213
              if (*p1++ != '<' || p[-2] != '>')
2214
                fatal ("specs %%include syntax malformed after %ld characters",
2215
                       (long) (p1 - buffer + 1));
2216
 
2217
              p[-2] = '\0';
2218
              new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2219
              if (new_filename)
2220
                read_specs (new_filename, FALSE);
2221
              else if (verbose_flag)
2222
                notice ("could not find specs file %s\n", p1);
2223
              continue;
2224
            }
2225
          else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2226
                   && (p1[sizeof "%rename" - 1] == ' '
2227
                       || p1[sizeof "%rename" - 1] == '\t'))
2228
            {
2229
              int name_len;
2230
              struct spec_list *sl;
2231
              struct spec_list *newsl;
2232
 
2233
              /* Get original name.  */
2234
              p1 += sizeof "%rename";
2235
              while (*p1 == ' ' || *p1 == '\t')
2236
                p1++;
2237
 
2238
              if (! ISALPHA ((unsigned char) *p1))
2239
                fatal ("specs %%rename syntax malformed after %ld characters",
2240
                       (long) (p1 - buffer));
2241
 
2242
              p2 = p1;
2243
              while (*p2 && !ISSPACE ((unsigned char) *p2))
2244
                p2++;
2245
 
2246
              if (*p2 != ' ' && *p2 != '\t')
2247
                fatal ("specs %%rename syntax malformed after %ld characters",
2248
                       (long) (p2 - buffer));
2249
 
2250
              name_len = p2 - p1;
2251
              *p2++ = '\0';
2252
              while (*p2 == ' ' || *p2 == '\t')
2253
                p2++;
2254
 
2255
              if (! ISALPHA ((unsigned char) *p2))
2256
                fatal ("specs %%rename syntax malformed after %ld characters",
2257
                       (long) (p2 - buffer));
2258
 
2259
              /* Get new spec name.  */
2260
              p3 = p2;
2261
              while (*p3 && !ISSPACE ((unsigned char) *p3))
2262
                p3++;
2263
 
2264
              if (p3 != p - 1)
2265
                fatal ("specs %%rename syntax malformed after %ld characters",
2266
                       (long) (p3 - buffer));
2267
              *p3 = '\0';
2268
 
2269
              for (sl = specs; sl; sl = sl->next)
2270
                if (name_len == sl->name_len && !strcmp (sl->name, p1))
2271
                  break;
2272
 
2273
              if (!sl)
2274
                fatal ("specs %s spec was not found to be renamed", p1);
2275
 
2276
              if (strcmp (p1, p2) == 0)
2277
                continue;
2278
 
2279
              for (newsl = specs; newsl; newsl = newsl->next)
2280
                if (strcmp (newsl->name, p2) == 0)
2281
                  fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2282
                    filename, p1, p2);
2283
 
2284
              if (verbose_flag)
2285
                {
2286
                  notice ("rename spec %s to %s\n", p1, p2);
2287
#ifdef DEBUG_SPECS
2288
                  notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2289
#endif
2290
                }
2291
 
2292
              set_spec (p2, *(sl->ptr_spec));
2293
              if (sl->alloc_p)
2294
                free (CONST_CAST (char *, *(sl->ptr_spec)));
2295
 
2296
              *(sl->ptr_spec) = "";
2297
              sl->alloc_p = 0;
2298
              continue;
2299
            }
2300
          else
2301
            fatal ("specs unknown %% command after %ld characters",
2302
                   (long) (p1 - buffer));
2303
        }
2304
 
2305
      /* Find the colon that should end the suffix.  */
2306
      p1 = p;
2307
      while (*p1 && *p1 != ':' && *p1 != '\n')
2308
        p1++;
2309
 
2310
      /* The colon shouldn't be missing.  */
2311
      if (*p1 != ':')
2312
        fatal ("specs file malformed after %ld characters",
2313
               (long) (p1 - buffer));
2314
 
2315
      /* Skip back over trailing whitespace.  */
2316
      p2 = p1;
2317
      while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2318
        p2--;
2319
 
2320
      /* Copy the suffix to a string.  */
2321
      suffix = save_string (p, p2 - p);
2322
      /* Find the next line.  */
2323
      p = skip_whitespace (p1 + 1);
2324
      if (p[1] == 0)
2325
        fatal ("specs file malformed after %ld characters",
2326
               (long) (p - buffer));
2327
 
2328
      p1 = p;
2329
      /* Find next blank line or end of string.  */
2330
      while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2331
        p1++;
2332
 
2333
      /* Specs end at the blank line and do not include the newline.  */
2334
      spec = save_string (p, p1 - p);
2335
      p = p1;
2336
 
2337
      /* Delete backslash-newline sequences from the spec.  */
2338
      in = spec;
2339
      out = spec;
2340
      while (*in != 0)
2341
        {
2342
          if (in[0] == '\\' && in[1] == '\n')
2343
            in += 2;
2344
          else if (in[0] == '#')
2345
            while (*in && *in != '\n')
2346
              in++;
2347
 
2348
          else
2349
            *out++ = *in++;
2350
        }
2351
      *out = 0;
2352
 
2353
      if (suffix[0] == '*')
2354
        {
2355
          if (! strcmp (suffix, "*link_command"))
2356
            link_command_spec = spec;
2357
          else
2358
            set_spec (suffix + 1, spec);
2359
        }
2360
      else
2361
        {
2362
          /* Add this pair to the vector.  */
2363
          compilers
2364
            = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2365
 
2366
          compilers[n_compilers].suffix = suffix;
2367
          compilers[n_compilers].spec = spec;
2368
          n_compilers++;
2369
          memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2370
        }
2371
 
2372
      if (*suffix == 0)
2373
        link_command_spec = spec;
2374
    }
2375
 
2376
  if (link_command_spec == 0)
2377
    fatal ("spec file has no spec for linking");
2378
}
2379
 
2380
/* Record the names of temporary files we tell compilers to write,
2381
   and delete them at the end of the run.  */
2382
 
2383
/* This is the common prefix we use to make temp file names.
2384
   It is chosen once for each run of this program.
2385
   It is substituted into a spec by %g or %j.
2386
   Thus, all temp file names contain this prefix.
2387
   In practice, all temp file names start with this prefix.
2388
 
2389
   This prefix comes from the envvar TMPDIR if it is defined;
2390
   otherwise, from the P_tmpdir macro if that is defined;
2391
   otherwise, in /usr/tmp or /tmp;
2392
   or finally the current directory if all else fails.  */
2393
 
2394
static const char *temp_filename;
2395
 
2396
/* Length of the prefix.  */
2397
 
2398
static int temp_filename_length;
2399
 
2400
/* Define the list of temporary files to delete.  */
2401
 
2402
struct temp_file
2403
{
2404
  const char *name;
2405
  struct temp_file *next;
2406
};
2407
 
2408
/* Queue of files to delete on success or failure of compilation.  */
2409
static struct temp_file *always_delete_queue;
2410
/* Queue of files to delete on failure of compilation.  */
2411
static struct temp_file *failure_delete_queue;
2412
 
2413
/* Record FILENAME as a file to be deleted automatically.
2414
   ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2415
   otherwise delete it in any case.
2416
   FAIL_DELETE nonzero means delete it if a compilation step fails;
2417
   otherwise delete it in any case.  */
2418
 
2419
void
2420
record_temp_file (const char *filename, int always_delete, int fail_delete)
2421
{
2422
  char *const name = xstrdup (filename);
2423
 
2424
  if (always_delete)
2425
    {
2426
      struct temp_file *temp;
2427
      for (temp = always_delete_queue; temp; temp = temp->next)
2428
        if (! strcmp (name, temp->name))
2429
          goto already1;
2430
 
2431
      temp = XNEW (struct temp_file);
2432
      temp->next = always_delete_queue;
2433
      temp->name = name;
2434
      always_delete_queue = temp;
2435
 
2436
    already1:;
2437
    }
2438
 
2439
  if (fail_delete)
2440
    {
2441
      struct temp_file *temp;
2442
      for (temp = failure_delete_queue; temp; temp = temp->next)
2443
        if (! strcmp (name, temp->name))
2444
          goto already2;
2445
 
2446
      temp = XNEW (struct temp_file);
2447
      temp->next = failure_delete_queue;
2448
      temp->name = name;
2449
      failure_delete_queue = temp;
2450
 
2451
    already2:;
2452
    }
2453
}
2454
 
2455
/* Delete all the temporary files whose names we previously recorded.  */
2456
 
2457
#ifndef DELETE_IF_ORDINARY
2458
#define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
2459
do                                                      \
2460
  {                                                     \
2461
    if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
2462
      if (unlink (NAME) < 0)                            \
2463
        if (VERBOSE_FLAG)                               \
2464
          perror_with_name (NAME);                      \
2465
  } while (0)
2466
#endif
2467
 
2468
static void
2469
delete_if_ordinary (const char *name)
2470
{
2471
  struct stat st;
2472
#ifdef DEBUG
2473
  int i, c;
2474
 
2475
  printf ("Delete %s? (y or n) ", name);
2476
  fflush (stdout);
2477
  i = getchar ();
2478
  if (i != '\n')
2479
    while ((c = getchar ()) != '\n' && c != EOF)
2480
      ;
2481
 
2482
  if (i == 'y' || i == 'Y')
2483
#endif /* DEBUG */
2484
  DELETE_IF_ORDINARY (name, st, verbose_flag);
2485
}
2486
 
2487
static void
2488
delete_temp_files (void)
2489
{
2490
  struct temp_file *temp;
2491
 
2492
  for (temp = always_delete_queue; temp; temp = temp->next)
2493
    delete_if_ordinary (temp->name);
2494
  always_delete_queue = 0;
2495
}
2496
 
2497
/* Delete all the files to be deleted on error.  */
2498
 
2499
static void
2500
delete_failure_queue (void)
2501
{
2502
  struct temp_file *temp;
2503
 
2504
  for (temp = failure_delete_queue; temp; temp = temp->next)
2505
    delete_if_ordinary (temp->name);
2506
}
2507
 
2508
static void
2509
clear_failure_queue (void)
2510
{
2511
  failure_delete_queue = 0;
2512
}
2513
 
2514
/* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2515
   returns non-NULL.
2516
   If DO_MULTI is true iterate over the paths twice, first with multilib
2517
   suffix then without, otherwise iterate over the paths once without
2518
   adding a multilib suffix.  When DO_MULTI is true, some attempt is made
2519
   to avoid visiting the same path twice, but we could do better.  For
2520
   instance, /usr/lib/../lib is considered different from /usr/lib.
2521
   At least EXTRA_SPACE chars past the end of the path passed to
2522
   CALLBACK are available for use by the callback.
2523
   CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2524
 
2525
   Returns the value returned by CALLBACK.  */
2526
 
2527
static void *
2528
for_each_path (const struct path_prefix *paths,
2529
               bool do_multi,
2530
               size_t extra_space,
2531
               void *(*callback) (char *, void *),
2532
               void *callback_info)
2533
{
2534
  struct prefix_list *pl;
2535
  const char *multi_dir = NULL;
2536
  const char *multi_os_dir = NULL;
2537
  const char *multi_suffix;
2538
  const char *just_multi_suffix;
2539
  char *path = NULL;
2540
  void *ret = NULL;
2541
  bool skip_multi_dir = false;
2542
  bool skip_multi_os_dir = false;
2543
 
2544
  multi_suffix = machine_suffix;
2545
  just_multi_suffix = just_machine_suffix;
2546
  if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2547
    {
2548
      multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2549
      multi_suffix = concat (multi_suffix, multi_dir, NULL);
2550
      just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2551
    }
2552
  if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2553
    multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2554
 
2555
  while (1)
2556
    {
2557
      size_t multi_dir_len = 0;
2558
      size_t multi_os_dir_len = 0;
2559
      size_t suffix_len;
2560
      size_t just_suffix_len;
2561
      size_t len;
2562
 
2563
      if (multi_dir)
2564
        multi_dir_len = strlen (multi_dir);
2565
      if (multi_os_dir)
2566
        multi_os_dir_len = strlen (multi_os_dir);
2567
      suffix_len = strlen (multi_suffix);
2568
      just_suffix_len = strlen (just_multi_suffix);
2569
 
2570
      if (path == NULL)
2571
        {
2572
          len = paths->max_len + extra_space + 1;
2573
          if (suffix_len > multi_os_dir_len)
2574
            len += suffix_len;
2575
          else
2576
            len += multi_os_dir_len;
2577
          path = XNEWVEC (char, len);
2578
        }
2579
 
2580
      for (pl = paths->plist; pl != 0; pl = pl->next)
2581
        {
2582
          len = strlen (pl->prefix);
2583
          memcpy (path, pl->prefix, len);
2584
 
2585
          /* Look first in MACHINE/VERSION subdirectory.  */
2586
          if (!skip_multi_dir)
2587
            {
2588
              memcpy (path + len, multi_suffix, suffix_len + 1);
2589
              ret = callback (path, callback_info);
2590
              if (ret)
2591
                break;
2592
            }
2593
 
2594
          /* Some paths are tried with just the machine (ie. target)
2595
             subdir.  This is used for finding as, ld, etc.  */
2596
          if (!skip_multi_dir
2597
              && pl->require_machine_suffix == 2)
2598
            {
2599
              memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2600
              ret = callback (path, callback_info);
2601
              if (ret)
2602
                break;
2603
            }
2604
 
2605
          /* Now try the base path.  */
2606
          if (!pl->require_machine_suffix
2607
              && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2608
            {
2609
              const char *this_multi;
2610
              size_t this_multi_len;
2611
 
2612
              if (pl->os_multilib)
2613
                {
2614
                  this_multi = multi_os_dir;
2615
                  this_multi_len = multi_os_dir_len;
2616
                }
2617
              else
2618
                {
2619
                  this_multi = multi_dir;
2620
                  this_multi_len = multi_dir_len;
2621
                }
2622
 
2623
              if (this_multi_len)
2624
                memcpy (path + len, this_multi, this_multi_len + 1);
2625
              else
2626
                path[len] = '\0';
2627
 
2628
              ret = callback (path, callback_info);
2629
              if (ret)
2630
                break;
2631
            }
2632
        }
2633
      if (pl)
2634
        break;
2635
 
2636
      if (multi_dir == NULL && multi_os_dir == NULL)
2637
        break;
2638
 
2639
      /* Run through the paths again, this time without multilibs.
2640
         Don't repeat any we have already seen.  */
2641
      if (multi_dir)
2642
        {
2643
          free (CONST_CAST (char *, multi_dir));
2644
          multi_dir = NULL;
2645
          free (CONST_CAST (char *, multi_suffix));
2646
          multi_suffix = machine_suffix;
2647
          free (CONST_CAST (char *, just_multi_suffix));
2648
          just_multi_suffix = just_machine_suffix;
2649
        }
2650
      else
2651
        skip_multi_dir = true;
2652
      if (multi_os_dir)
2653
        {
2654
          free (CONST_CAST (char *, multi_os_dir));
2655
          multi_os_dir = NULL;
2656
        }
2657
      else
2658
        skip_multi_os_dir = true;
2659
    }
2660
 
2661
  if (multi_dir)
2662
    {
2663
      free (CONST_CAST (char *, multi_dir));
2664
      free (CONST_CAST (char *, multi_suffix));
2665
      free (CONST_CAST (char *, just_multi_suffix));
2666
    }
2667
  if (multi_os_dir)
2668
    free (CONST_CAST (char *, multi_os_dir));
2669
  if (ret != path)
2670
    free (path);
2671
  return ret;
2672
}
2673
 
2674
/* Callback for build_search_list.  Adds path to obstack being built.  */
2675
 
2676
struct add_to_obstack_info {
2677
  struct obstack *ob;
2678
  bool check_dir;
2679
  bool first_time;
2680
};
2681
 
2682
static void *
2683
add_to_obstack (char *path, void *data)
2684
{
2685
  struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2686
 
2687
  if (info->check_dir && !is_directory (path, false))
2688
    return NULL;
2689
 
2690
  if (!info->first_time)
2691
    obstack_1grow (info->ob, PATH_SEPARATOR);
2692
 
2693
  obstack_grow (info->ob, path, strlen (path));
2694
 
2695
  info->first_time = false;
2696
  return NULL;
2697
}
2698
 
2699
/* Add or change the value of an environment variable, outputting the
2700
   change to standard error if in verbose mode.  */
2701
static void
2702
xputenv (const char *string)
2703
{
2704
  if (verbose_flag)
2705
    notice ("%s\n", string);
2706
  putenv (CONST_CAST (char *, string));
2707
}
2708
 
2709
/* Build a list of search directories from PATHS.
2710
   PREFIX is a string to prepend to the list.
2711
   If CHECK_DIR_P is true we ensure the directory exists.
2712
   If DO_MULTI is true, multilib paths are output first, then
2713
   non-multilib paths.
2714
   This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2715
   It is also used by the --print-search-dirs flag.  */
2716
 
2717
static char *
2718
build_search_list (const struct path_prefix *paths, const char *prefix,
2719
                   bool check_dir, bool do_multi)
2720
{
2721
  struct add_to_obstack_info info;
2722
 
2723
  info.ob = &collect_obstack;
2724
  info.check_dir = check_dir;
2725
  info.first_time = true;
2726
 
2727
  obstack_grow (&collect_obstack, prefix, strlen (prefix));
2728
  obstack_1grow (&collect_obstack, '=');
2729
 
2730
  for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2731
 
2732
  obstack_1grow (&collect_obstack, '\0');
2733
  return XOBFINISH (&collect_obstack, char *);
2734
}
2735
 
2736
/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2737
   for collect.  */
2738
 
2739
static void
2740
putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2741
                      bool do_multi)
2742
{
2743
  xputenv (build_search_list (paths, env_var, true, do_multi));
2744
}
2745
 
2746
/* Check whether NAME can be accessed in MODE.  This is like access,
2747
   except that it never considers directories to be executable.  */
2748
 
2749
static int
2750
access_check (const char *name, int mode)
2751
{
2752
  if (mode == X_OK)
2753
    {
2754
      struct stat st;
2755
 
2756
      if (stat (name, &st) < 0
2757
          || S_ISDIR (st.st_mode))
2758
        return -1;
2759
    }
2760
 
2761
  return access (name, mode);
2762
}
2763
 
2764
/* Callback for find_a_file.  Appends the file name to the directory
2765
   path.  If the resulting file exists in the right mode, return the
2766
   full pathname to the file.  */
2767
 
2768
struct file_at_path_info {
2769
  const char *name;
2770
  const char *suffix;
2771
  int name_len;
2772
  int suffix_len;
2773
  int mode;
2774
};
2775
 
2776
static void *
2777
file_at_path (char *path, void *data)
2778
{
2779
  struct file_at_path_info *info = (struct file_at_path_info *) data;
2780
  size_t len = strlen (path);
2781
 
2782
  memcpy (path + len, info->name, info->name_len);
2783
  len += info->name_len;
2784
 
2785
  /* Some systems have a suffix for executable files.
2786
     So try appending that first.  */
2787
  if (info->suffix_len)
2788
    {
2789
      memcpy (path + len, info->suffix, info->suffix_len + 1);
2790
      if (access_check (path, info->mode) == 0)
2791
        return path;
2792
    }
2793
 
2794
  path[len] = '\0';
2795
  if (access_check (path, info->mode) == 0)
2796
    return path;
2797
 
2798
  return NULL;
2799
}
2800
 
2801
/* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2802
   access to check permissions.  If DO_MULTI is true, search multilib
2803
   paths then non-multilib paths, otherwise do not search multilib paths.
2804
   Return 0 if not found, otherwise return its name, allocated with malloc.  */
2805
 
2806
static char *
2807
find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2808
             bool do_multi)
2809
{
2810
  struct file_at_path_info info;
2811
 
2812
#ifdef DEFAULT_ASSEMBLER
2813
  if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2814
    return xstrdup (DEFAULT_ASSEMBLER);
2815
#endif
2816
 
2817
#ifdef DEFAULT_LINKER
2818
  if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2819
    return xstrdup (DEFAULT_LINKER);
2820
#endif
2821
 
2822
  /* Determine the filename to execute (special case for absolute paths).  */
2823
 
2824
  if (IS_ABSOLUTE_PATH (name))
2825
    {
2826
      if (access (name, mode) == 0)
2827
        return xstrdup (name);
2828
 
2829
      return NULL;
2830
    }
2831
 
2832
  info.name = name;
2833
  info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2834
  info.name_len = strlen (info.name);
2835
  info.suffix_len = strlen (info.suffix);
2836
  info.mode = mode;
2837
 
2838
  return (char*) for_each_path (pprefix, do_multi,
2839
                                info.name_len + info.suffix_len,
2840
                                file_at_path, &info);
2841
}
2842
 
2843
/* Ranking of prefixes in the sort list. -B prefixes are put before
2844
   all others.  */
2845
 
2846
enum path_prefix_priority
2847
{
2848
  PREFIX_PRIORITY_B_OPT,
2849
  PREFIX_PRIORITY_LAST
2850
};
2851
 
2852
/* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2853
   order according to PRIORITY.  Within each PRIORITY, new entries are
2854
   appended.
2855
 
2856
   If WARN is nonzero, we will warn if no file is found
2857
   through this prefix.  WARN should point to an int
2858
   which will be set to 1 if this entry is used.
2859
 
2860
   COMPONENT is the value to be passed to update_path.
2861
 
2862
   REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2863
   the complete value of machine_suffix.
2864
   2 means try both machine_suffix and just_machine_suffix.  */
2865
 
2866
static void
2867
add_prefix (struct path_prefix *pprefix, const char *prefix,
2868
            const char *component, /* enum prefix_priority */ int priority,
2869
            int require_machine_suffix, int os_multilib)
2870
{
2871
  struct prefix_list *pl, **prev;
2872
  int len;
2873
 
2874
  for (prev = &pprefix->plist;
2875
       (*prev) != NULL && (*prev)->priority <= priority;
2876
       prev = &(*prev)->next)
2877
    ;
2878
 
2879
  /* Keep track of the longest prefix.  */
2880
 
2881
  prefix = update_path (prefix, component);
2882
  len = strlen (prefix);
2883
  if (len > pprefix->max_len)
2884
    pprefix->max_len = len;
2885
 
2886
  pl = XNEW (struct prefix_list);
2887
  pl->prefix = prefix;
2888
  pl->require_machine_suffix = require_machine_suffix;
2889
  pl->priority = priority;
2890
  pl->os_multilib = os_multilib;
2891
 
2892
  /* Insert after PREV.  */
2893
  pl->next = (*prev);
2894
  (*prev) = pl;
2895
}
2896
 
2897
/* Same as add_prefix, but prepending target_system_root to prefix.  */
2898
/* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
2899
static void
2900
add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2901
                      const char *component,
2902
                      /* enum prefix_priority */ int priority,
2903
                      int require_machine_suffix, int os_multilib)
2904
{
2905
  if (!IS_ABSOLUTE_PATH (prefix))
2906
    fatal ("system path '%s' is not absolute", prefix);
2907
 
2908
  if (target_system_root)
2909
    {
2910
      if (target_sysroot_suffix)
2911
          prefix = concat (target_sysroot_suffix, prefix, NULL);
2912
      prefix = concat (target_system_root, prefix, NULL);
2913
 
2914
      /* We have to override this because GCC's notion of sysroot
2915
         moves along with GCC.  */
2916
      component = "GCC";
2917
    }
2918
 
2919
  add_prefix (pprefix, prefix, component, priority,
2920
              require_machine_suffix, os_multilib);
2921
}
2922
 
2923
/* Execute the command specified by the arguments on the current line of spec.
2924
   When using pipes, this includes several piped-together commands
2925
   with `|' between them.
2926
 
2927
   Return 0 if successful, -1 if failed.  */
2928
 
2929
static int
2930
execute (void)
2931
{
2932
  int i;
2933
  int n_commands;               /* # of command.  */
2934
  char *string;
2935
  struct pex_obj *pex;
2936
  struct command
2937
  {
2938
    const char *prog;           /* program name.  */
2939
    const char **argv;          /* vector of args.  */
2940
  };
2941
 
2942
  struct command *commands;     /* each command buffer with above info.  */
2943
 
2944
  gcc_assert (!processing_spec_function);
2945
 
2946
  if (wrapper_string)
2947
    {
2948
      string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
2949
      argbuf[0] = (string) ? string : argbuf[0];
2950
      insert_wrapper (wrapper_string);
2951
    }
2952
 
2953
  /* Count # of piped commands.  */
2954
  for (n_commands = 1, i = 0; i < argbuf_index; i++)
2955
    if (strcmp (argbuf[i], "|") == 0)
2956
      n_commands++;
2957
 
2958
  /* Get storage for each command.  */
2959
  commands = (struct command *) alloca (n_commands * sizeof (struct command));
2960
 
2961
  /* Split argbuf into its separate piped processes,
2962
     and record info about each one.
2963
     Also search for the programs that are to be run.  */
2964
 
2965
  commands[0].prog = argbuf[0]; /* first command.  */
2966
  commands[0].argv = &argbuf[0];
2967
 
2968
  if (!wrapper_string)
2969
    {
2970
      string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2971
      commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2972
    }
2973
 
2974
  for (n_commands = 1, i = 0; i < argbuf_index; i++)
2975
    if (strcmp (argbuf[i], "|") == 0)
2976
      {                         /* each command.  */
2977
#if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2978
        fatal ("-pipe not supported");
2979
#endif
2980
        argbuf[i] = 0;   /* termination of command args.  */
2981
        commands[n_commands].prog = argbuf[i + 1];
2982
        commands[n_commands].argv = &argbuf[i + 1];
2983
        string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2984
                              X_OK, false);
2985
        if (string)
2986
          commands[n_commands].argv[0] = string;
2987
        n_commands++;
2988
      }
2989
 
2990
  argbuf[argbuf_index] = 0;
2991
 
2992
  /* If -v, print what we are about to do, and maybe query.  */
2993
 
2994
  if (verbose_flag)
2995
    {
2996
      /* For help listings, put a blank line between sub-processes.  */
2997
      if (print_help_list)
2998
        fputc ('\n', stderr);
2999
 
3000
      /* Print each piped command as a separate line.  */
3001
      for (i = 0; i < n_commands; i++)
3002
        {
3003
          const char *const *j;
3004
 
3005
          if (verbose_only_flag)
3006
            {
3007
              for (j = commands[i].argv; *j; j++)
3008
                {
3009
                  const char *p;
3010
                  fprintf (stderr, " \"");
3011
                  for (p = *j; *p; ++p)
3012
                    {
3013
                      if (*p == '"' || *p == '\\' || *p == '$')
3014
                        fputc ('\\', stderr);
3015
                      fputc (*p, stderr);
3016
                    }
3017
                  fputc ('"', stderr);
3018
                }
3019
            }
3020
          else
3021
            for (j = commands[i].argv; *j; j++)
3022
              fprintf (stderr, " %s", *j);
3023
 
3024
          /* Print a pipe symbol after all but the last command.  */
3025
          if (i + 1 != n_commands)
3026
            fprintf (stderr, " |");
3027
          fprintf (stderr, "\n");
3028
        }
3029
      fflush (stderr);
3030
      if (verbose_only_flag != 0)
3031
        {
3032
          /* verbose_only_flag should act as if the spec was
3033
             executed, so increment execution_count before
3034
             returning.  This prevents spurious warnings about
3035
             unused linker input files, etc.  */
3036
          execution_count++;
3037
          return 0;
3038
        }
3039
#ifdef DEBUG
3040
      notice ("\nGo ahead? (y or n) ");
3041
      fflush (stderr);
3042
      i = getchar ();
3043
      if (i != '\n')
3044
        while (getchar () != '\n')
3045
          ;
3046
 
3047
      if (i != 'y' && i != 'Y')
3048
        return 0;
3049
#endif /* DEBUG */
3050
    }
3051
 
3052
#ifdef ENABLE_VALGRIND_CHECKING
3053
  /* Run the each command through valgrind.  To simplify prepending the
3054
     path to valgrind and the option "-q" (for quiet operation unless
3055
     something triggers), we allocate a separate argv array.  */
3056
 
3057
  for (i = 0; i < n_commands; i++)
3058
    {
3059
      const char **argv;
3060
      int argc;
3061
      int j;
3062
 
3063
      for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3064
        ;
3065
 
3066
      argv = XALLOCAVEC (const char *, argc + 3);
3067
 
3068
      argv[0] = VALGRIND_PATH;
3069
      argv[1] = "-q";
3070
      for (j = 2; j < argc + 2; j++)
3071
        argv[j] = commands[i].argv[j - 2];
3072
      argv[j] = NULL;
3073
 
3074
      commands[i].argv = argv;
3075
      commands[i].prog = argv[0];
3076
    }
3077
#endif
3078
 
3079
  /* Run each piped subprocess.  */
3080
 
3081
  pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3082
                                   ? PEX_RECORD_TIMES : 0),
3083
                  programname, temp_filename);
3084
  if (pex == NULL)
3085
    pfatal_with_name (_("pex_init failed"));
3086
 
3087
  for (i = 0; i < n_commands; i++)
3088
    {
3089
      const char *errmsg;
3090
      int err;
3091
      const char *string = commands[i].argv[0];
3092
 
3093
      errmsg = pex_run (pex,
3094
                        ((i + 1 == n_commands ? PEX_LAST : 0)
3095
                         | (string == commands[i].prog ? PEX_SEARCH : 0)),
3096
                        string, CONST_CAST (char **, commands[i].argv),
3097
                        NULL, NULL, &err);
3098
      if (errmsg != NULL)
3099
        {
3100
          if (err == 0)
3101
            fatal (errmsg);
3102
          else
3103
            {
3104
              errno = err;
3105
              pfatal_with_name (errmsg);
3106
            }
3107
        }
3108
 
3109
      if (string != commands[i].prog)
3110
        free (CONST_CAST (char *, string));
3111
    }
3112
 
3113
  execution_count++;
3114
 
3115
  /* Wait for all the subprocesses to finish.  */
3116
 
3117
  {
3118
    int *statuses;
3119
    struct pex_time *times = NULL;
3120
    int ret_code = 0;
3121
 
3122
    statuses = (int *) alloca (n_commands * sizeof (int));
3123
    if (!pex_get_status (pex, n_commands, statuses))
3124
      pfatal_with_name (_("failed to get exit status"));
3125
 
3126
    if (report_times || report_times_to_file)
3127
      {
3128
        times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3129
        if (!pex_get_times (pex, n_commands, times))
3130
          pfatal_with_name (_("failed to get process times"));
3131
      }
3132
 
3133
    pex_free (pex);
3134
 
3135
    for (i = 0; i < n_commands; ++i)
3136
      {
3137
        int status = statuses[i];
3138
 
3139
        if (WIFSIGNALED (status))
3140
          {
3141
#ifdef SIGPIPE
3142
            /* SIGPIPE is a special case.  It happens in -pipe mode
3143
               when the compiler dies before the preprocessor is done,
3144
               or the assembler dies before the compiler is done.
3145
               There's generally been an error already, and this is
3146
               just fallout.  So don't generate another error unless
3147
               we would otherwise have succeeded.  */
3148
            if (WTERMSIG (status) == SIGPIPE
3149
                && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3150
              {
3151
                signal_count++;
3152
                ret_code = -1;
3153
              }
3154
            else
3155
#endif
3156
              fatal_ice ("\
3157
Internal error: %s (program %s)\n\
3158
Please submit a full bug report.\n\
3159
See %s for instructions.",
3160
                        strsignal (WTERMSIG (status)), commands[i].prog,
3161
                        bug_report_url);
3162
          }
3163
        else if (WIFEXITED (status)
3164
                 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3165
          {
3166
            if (WEXITSTATUS (status) > greatest_status)
3167
              greatest_status = WEXITSTATUS (status);
3168
            ret_code = -1;
3169
          }
3170
 
3171
        if (report_times || report_times_to_file)
3172
          {
3173
            struct pex_time *pt = &times[i];
3174
            double ut, st;
3175
 
3176
            ut = ((double) pt->user_seconds
3177
                  + (double) pt->user_microseconds / 1.0e6);
3178
            st = ((double) pt->system_seconds
3179
                  + (double) pt->system_microseconds / 1.0e6);
3180
 
3181
            if (ut + st != 0)
3182
              {
3183
                if (report_times)
3184
                  notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
3185
 
3186
                if (report_times_to_file)
3187
                  {
3188
                    int c = 0;
3189
                    const char *const *j;
3190
 
3191
                    fprintf (report_times_to_file, "%g %g", ut, st);
3192
 
3193
                    for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3194
                      {
3195
                        const char *p;
3196
                        for (p = *j; *p; ++p)
3197
                          if (*p == '"' || *p == '\\' || *p == '$'
3198
                              || ISSPACE (*p))
3199
                            break;
3200
 
3201
                        if (*p)
3202
                          {
3203
                            fprintf (report_times_to_file, " \"");
3204
                            for (p = *j; *p; ++p)
3205
                              {
3206
                                if (*p == '"' || *p == '\\' || *p == '$')
3207
                                  fputc ('\\', report_times_to_file);
3208
                                fputc (*p, report_times_to_file);
3209
                              }
3210
                            fputc ('"', report_times_to_file);
3211
                          }
3212
                        else
3213
                          fprintf (report_times_to_file, " %s", *j);
3214
                      }
3215
 
3216
                    fputc ('\n', report_times_to_file);
3217
                  }
3218
              }
3219
          }
3220
      }
3221
 
3222
    return ret_code;
3223
  }
3224
}
3225
 
3226
/* Find all the switches given to us
3227
   and make a vector describing them.
3228
   The elements of the vector are strings, one per switch given.
3229
   If a switch uses following arguments, then the `part1' field
3230
   is the switch itself and the `args' field
3231
   is a null-terminated vector containing the following arguments.
3232
   Bits in the `live_cond' field are:
3233
   SWITCH_LIVE to indicate this switch is true in a conditional spec.
3234
   SWITCH_FALSE to indicate this switch is overridden by a later switch.
3235
   SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3236
   SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3237
   in all do_spec calls afterwards.  Used for %<S from self specs.
3238
   The `validated' field is nonzero if any spec has looked at this switch;
3239
   if it remains zero at the end of the run, it must be meaningless.  */
3240
 
3241
#define SWITCH_LIVE                     0x1
3242
#define SWITCH_FALSE                    0x2
3243
#define SWITCH_IGNORE                   0x4
3244
#define SWITCH_IGNORE_PERMANENTLY       0x8
3245
 
3246
struct switchstr
3247
{
3248
  const char *part1;
3249
  const char **args;
3250
  unsigned int live_cond;
3251
  unsigned char validated;
3252
  unsigned char ordering;
3253
};
3254
 
3255
static struct switchstr *switches;
3256
 
3257
static int n_switches;
3258
 
3259
/* Set to zero if -fcompare-debug is disabled, positive if it's
3260
   enabled and we're running the first compilation, negative if it's
3261
   enabled and we're running the second compilation.  For most of the
3262
   time, it's in the range -1..1, but it can be temporarily set to 2
3263
   or 3 to indicate that the -fcompare-debug flags didn't come from
3264
   the command-line, but rather from the GCC_COMPARE_DEBUG environment
3265
   variable, until a synthesized -fcompare-debug flag is added to the
3266
   command line.  */
3267
int compare_debug;
3268
 
3269
/* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
3270
int compare_debug_second;
3271
 
3272
/* Set to the flags that should be passed to the second compilation in
3273
   a -fcompare-debug compilation.  */
3274
const char *compare_debug_opt;
3275
 
3276
static struct switchstr *switches_debug_check[2];
3277
 
3278
static int n_switches_debug_check[2];
3279
 
3280
static char *debug_check_temp_file[2];
3281
 
3282
/* Language is one of three things:
3283
 
3284
   1) The name of a real programming language.
3285
   2) NULL, indicating that no one has figured out
3286
   what it is yet.
3287
   3) '*', indicating that the file should be passed
3288
   to the linker.  */
3289
struct infile
3290
{
3291
  const char *name;
3292
  const char *language;
3293
  struct compiler *incompiler;
3294
  bool compiled;
3295
  bool preprocessed;
3296
};
3297
 
3298
/* Also a vector of input files specified.  */
3299
 
3300
static struct infile *infiles;
3301
 
3302
int n_infiles;
3303
 
3304
/* True if multiple input files are being compiled to a single
3305
   assembly file.  */
3306
 
3307
static bool combine_inputs;
3308
 
3309
/* This counts the number of libraries added by lang_specific_driver, so that
3310
   we can tell if there were any user supplied any files or libraries.  */
3311
 
3312
static int added_libraries;
3313
 
3314
/* And a vector of corresponding output files is made up later.  */
3315
 
3316
const char **outfiles;
3317
 
3318
#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3319
 
3320
/* Convert NAME to a new name if it is the standard suffix.  DO_EXE
3321
   is true if we should look for an executable suffix.  DO_OBJ
3322
   is true if we should look for an object suffix.  */
3323
 
3324
static const char *
3325
convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3326
                  int do_obj ATTRIBUTE_UNUSED)
3327
{
3328
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3329
  int i;
3330
#endif
3331
  int len;
3332
 
3333
  if (name == NULL)
3334
    return NULL;
3335
 
3336
  len = strlen (name);
3337
 
3338
#ifdef HAVE_TARGET_OBJECT_SUFFIX
3339
  /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
3340
  if (do_obj && len > 2
3341
      && name[len - 2] == '.'
3342
      && name[len - 1] == 'o')
3343
    {
3344
      obstack_grow (&obstack, name, len - 2);
3345
      obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3346
      name = XOBFINISH (&obstack, const char *);
3347
    }
3348
#endif
3349
 
3350
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3351
  /* If there is no filetype, make it the executable suffix (which includes
3352
     the ".").  But don't get confused if we have just "-o".  */
3353
  if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3354
    return name;
3355
 
3356
  for (i = len - 1; i >= 0; i--)
3357
    if (IS_DIR_SEPARATOR (name[i]))
3358
      break;
3359
 
3360
  for (i++; i < len; i++)
3361
    if (name[i] == '.')
3362
      return name;
3363
 
3364
  obstack_grow (&obstack, name, len);
3365
  obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3366
                 strlen (TARGET_EXECUTABLE_SUFFIX));
3367
  name = XOBFINISH (&obstack, const char *);
3368
#endif
3369
 
3370
  return name;
3371
}
3372
#endif
3373
 
3374
/* Display the command line switches accepted by gcc.  */
3375
static void
3376
display_help (void)
3377
{
3378
  printf (_("Usage: %s [options] file...\n"), programname);
3379
  fputs (_("Options:\n"), stdout);
3380
 
3381
  fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
3382
  fputs (_("  --help                   Display this information\n"), stdout);
3383
  fputs (_("  --target-help            Display target specific command line options\n"), stdout);
3384
  fputs (_("  --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3385
  fputs (_("                           Display specific types of command line options\n"), stdout);
3386
  if (! verbose_flag)
3387
    fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3388
  fputs (_("  --version                Display compiler version information\n"), stdout);
3389
  fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
3390
  fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
3391
  fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
3392
  fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
3393
  fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
3394
  fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
3395
  fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
3396
  fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
3397
  fputs (_("\
3398
  -print-multi-lib         Display the mapping between command line options and\n\
3399
                           multiple library search directories\n"), stdout);
3400
  fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3401
  fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
3402
  fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3403
  fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
3404
  fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
3405
  fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
3406
  fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
3407
  fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3408
  fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3409
  fputs (_("  -combine                 Pass multiple source files to compiler at once\n"), stdout);
3410
  fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3411
  fputs (_("  -save-temps=<arg>        Do not delete intermediate files\n"), stdout);
3412
  fputs (_("\
3413
  -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
3414
                           prefixes to other gcc components\n"), stdout);
3415
  fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3416
  fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3417
  fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3418
  fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3419
  fputs (_("\
3420
  --sysroot=<directory>    Use <directory> as the root directory for headers\n\
3421
                           and libraries\n"), stdout);
3422
  fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3423
  fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
3424
  fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
3425
  fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3426
  fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3427
  fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3428
  fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3429
  fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3430
  fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3431
  fputs (_("\
3432
  -x <language>            Specify the language of the following input files\n\
3433
                           Permissible languages include: c c++ assembler none\n\
3434
                           'none' means revert to the default behavior of\n\
3435
                           guessing the language based on the file's extension\n\
3436
"), stdout);
3437
 
3438
  printf (_("\
3439
\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3440
 passed on to the various sub-processes invoked by %s.  In order to pass\n\
3441
 other options on to these processes the -W<letter> options must be used.\n\
3442
"), programname);
3443
 
3444
  /* The rest of the options are displayed by invocations of the various
3445
     sub-processes.  */
3446
}
3447
 
3448
static void
3449
add_preprocessor_option (const char *option, int len)
3450
{
3451
  n_preprocessor_options++;
3452
 
3453
  if (! preprocessor_options)
3454
    preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
3455
  else
3456
    preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
3457
                                       n_preprocessor_options);
3458
 
3459
  preprocessor_options [n_preprocessor_options - 1] =
3460
    save_string (option, len);
3461
}
3462
 
3463
static void
3464
add_assembler_option (const char *option, int len)
3465
{
3466
  n_assembler_options++;
3467
 
3468
  if (! assembler_options)
3469
    assembler_options = XNEWVEC (char *, n_assembler_options);
3470
  else
3471
    assembler_options = XRESIZEVEC (char *, assembler_options,
3472
                                    n_assembler_options);
3473
 
3474
  assembler_options [n_assembler_options - 1] = save_string (option, len);
3475
}
3476
 
3477
static void
3478
add_linker_option (const char *option, int len)
3479
{
3480
  n_linker_options++;
3481
 
3482
  if (! linker_options)
3483
    linker_options = XNEWVEC (char *, n_linker_options);
3484
  else
3485
    linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);
3486
 
3487
  linker_options [n_linker_options - 1] = save_string (option, len);
3488
}
3489
 
3490
/* Create the vector `switches' and its contents.
3491
   Store its length in `n_switches'.  */
3492
 
3493
static void
3494
process_command (int argc, const char **argv)
3495
{
3496
  int i;
3497
  const char *temp;
3498
  char *temp1;
3499
  const char *spec_lang = 0;
3500
  int last_language_n_infiles;
3501
  int lang_n_infiles = 0;
3502
#ifdef MODIFY_TARGET_NAME
3503
  int is_modify_target_name;
3504
  unsigned int j;
3505
#endif
3506
  const char *tooldir_prefix;
3507
  char *(*get_relative_prefix) (const char *, const char *,
3508
                                const char *) = NULL;
3509
 
3510
  GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3511
 
3512
  n_switches = 0;
3513
  n_infiles = 0;
3514
  added_libraries = 0;
3515
 
3516
  /* Figure compiler version from version string.  */
3517
 
3518
  compiler_version = temp1 = xstrdup (version_string);
3519
 
3520
  for (; *temp1; ++temp1)
3521
    {
3522
      if (*temp1 == ' ')
3523
        {
3524
          *temp1 = '\0';
3525
          break;
3526
        }
3527
    }
3528
 
3529
  /* If there is a -V or -b option (or both), process it now, before
3530
     trying to interpret the rest of the command line.
3531
     Use heuristic that all configuration names must have at least
3532
     one dash '-'. This allows us to pass options starting with -b.  */
3533
  if (argc > 1 && argv[1][0] == '-'
3534
      && (argv[1][1] == 'V'
3535
          || (argv[1][1] == 'b'
3536
              && (argv[1][2] == '\0'
3537
                  || NULL != strchr (argv[1] + 2, '-')))))
3538
    {
3539
      const char *new_version = DEFAULT_TARGET_VERSION;
3540
      const char *new_machine = DEFAULT_TARGET_MACHINE;
3541
      const char *progname = argv[0];
3542
      char **new_argv;
3543
      char *new_argv0;
3544
      int baselen;
3545
      int status = 0;
3546
      int err = 0;
3547
      const char *errmsg;
3548
 
3549
      while (argc > 1 && argv[1][0] == '-'
3550
             && (argv[1][1] == 'V'
3551
                 || (argv[1][1] == 'b'
3552
                     && (argv[1][2] == '\0'
3553
                         || NULL != strchr (argv[1] + 2, '-')))))
3554
        {
3555
          char opt = argv[1][1];
3556
          const char *arg;
3557
          if (argv[1][2] != '\0')
3558
            {
3559
              arg = argv[1] + 2;
3560
              argc -= 1;
3561
              argv += 1;
3562
            }
3563
          else if (argc > 2)
3564
            {
3565
              arg = argv[2];
3566
              argc -= 2;
3567
              argv += 2;
3568
            }
3569
          else
3570
            fatal ("'-%c' option must have argument", opt);
3571
          if (opt == 'V')
3572
            new_version = arg;
3573
          else
3574
            new_machine = arg;
3575
        }
3576
 
3577
      for (baselen = strlen (progname); baselen > 0; baselen--)
3578
        if (IS_DIR_SEPARATOR (progname[baselen-1]))
3579
          break;
3580
      new_argv0 = XDUPVAR (char, progname, baselen,
3581
                           baselen + concat_length (new_version, new_machine,
3582
                                                    "-gcc-", NULL) + 1);
3583
      strcpy (new_argv0 + baselen, new_machine);
3584
      strcat (new_argv0, "-gcc-");
3585
      strcat (new_argv0, new_version);
3586
 
3587
      new_argv = XDUPVEC (char *, argv, argc + 1);
3588
      new_argv[0] = new_argv0;
3589
 
3590
      errmsg = pex_one (PEX_SEARCH, new_argv0, new_argv, progname, NULL,
3591
                        NULL, &status, &err);
3592
 
3593
      if (errmsg)
3594
        {
3595
          if (err == 0)
3596
            fatal ("couldn't run '%s': %s", new_argv0, errmsg);
3597
          else
3598
            fatal ("couldn't run '%s': %s: %s", new_argv0, errmsg,
3599
                    xstrerror (err));
3600
        }
3601
      exit (status);
3602
    }
3603
 
3604
  /* Convert new-style -- options to old-style.  */
3605
  translate_options (&argc,
3606
                     CONST_CAST2 (const char *const **, const char ***,
3607
                                  &argv));
3608
 
3609
  /* Handle any -no-canonical-prefixes flag early, to assign the function
3610
     that builds relative prefixes.  This function creates default search
3611
     paths that are needed later in normal option handling.  */
3612
 
3613
  for (i = 1; i < argc; i++)
3614
    {
3615
      if (! strcmp (argv[i], "-no-canonical-prefixes"))
3616
        {
3617
          get_relative_prefix = make_relative_prefix_ignore_links;
3618
          break;
3619
        }
3620
    }
3621
  if (! get_relative_prefix)
3622
    get_relative_prefix = make_relative_prefix;
3623
 
3624
  /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3625
     see if we can create it from the pathname specified in argv[0].  */
3626
 
3627
  gcc_libexec_prefix = standard_libexec_prefix;
3628
#ifndef VMS
3629
  /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3630
  if (!gcc_exec_prefix)
3631
    {
3632
      gcc_exec_prefix = get_relative_prefix (argv[0],
3633
                                             standard_bindir_prefix,
3634
                                             standard_exec_prefix);
3635
      gcc_libexec_prefix = get_relative_prefix (argv[0],
3636
                                             standard_bindir_prefix,
3637
                                             standard_libexec_prefix);
3638
      if (gcc_exec_prefix)
3639
        xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3640
    }
3641
  else
3642
    {
3643
      /* make_relative_prefix requires a program name, but
3644
         GCC_EXEC_PREFIX is typically a directory name with a trailing
3645
         / (which is ignored by make_relative_prefix), so append a
3646
         program name.  */
3647
      char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3648
      gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3649
                                                standard_exec_prefix,
3650
                                                standard_libexec_prefix);
3651
 
3652
      /* The path is unrelocated, so fallback to the original setting.  */
3653
      if (!gcc_libexec_prefix)
3654
        gcc_libexec_prefix = standard_libexec_prefix;
3655
 
3656
      free (tmp_prefix);
3657
    }
3658
#else
3659
#endif
3660
  /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3661
     is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3662
     or an automatically created GCC_EXEC_PREFIX from argv[0].  */
3663
 
3664
  /* Do language-specific adjustment/addition of flags.  */
3665
  lang_specific_driver (&argc,
3666
                        CONST_CAST2 (const char *const **, const char ***,
3667
                                     &argv),
3668
                        &added_libraries);
3669
 
3670
  if (gcc_exec_prefix)
3671
    {
3672
      int len = strlen (gcc_exec_prefix);
3673
 
3674
      if (len > (int) sizeof ("/lib/gcc/") - 1
3675
          && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3676
        {
3677
          temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3678
          if (IS_DIR_SEPARATOR (*temp)
3679
              && strncmp (temp + 1, "lib", 3) == 0
3680
              && IS_DIR_SEPARATOR (temp[4])
3681
              && strncmp (temp + 5, "gcc", 3) == 0)
3682
            len -= sizeof ("/lib/gcc/") - 1;
3683
        }
3684
 
3685
      set_std_prefix (gcc_exec_prefix, len);
3686
      add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3687
                  PREFIX_PRIORITY_LAST, 0, 0);
3688
      add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3689
                  PREFIX_PRIORITY_LAST, 0, 0);
3690
    }
3691
 
3692
  /* COMPILER_PATH and LIBRARY_PATH have values
3693
     that are lists of directory names with colons.  */
3694
 
3695
  GET_ENVIRONMENT (temp, "COMPILER_PATH");
3696
  if (temp)
3697
    {
3698
      const char *startp, *endp;
3699
      char *nstore = (char *) alloca (strlen (temp) + 3);
3700
 
3701
      startp = endp = temp;
3702
      while (1)
3703
        {
3704
          if (*endp == PATH_SEPARATOR || *endp == 0)
3705
            {
3706
              strncpy (nstore, startp, endp - startp);
3707
              if (endp == startp)
3708
                strcpy (nstore, concat (".", dir_separator_str, NULL));
3709
              else if (!IS_DIR_SEPARATOR (endp[-1]))
3710
                {
3711
                  nstore[endp - startp] = DIR_SEPARATOR;
3712
                  nstore[endp - startp + 1] = 0;
3713
                }
3714
              else
3715
                nstore[endp - startp] = 0;
3716
              add_prefix (&exec_prefixes, nstore, 0,
3717
                          PREFIX_PRIORITY_LAST, 0, 0);
3718
              add_prefix (&include_prefixes, nstore, 0,
3719
                          PREFIX_PRIORITY_LAST, 0, 0);
3720
              if (*endp == 0)
3721
                break;
3722
              endp = startp = endp + 1;
3723
            }
3724
          else
3725
            endp++;
3726
        }
3727
    }
3728
 
3729
  GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3730
  if (temp && *cross_compile == '0')
3731
    {
3732
      const char *startp, *endp;
3733
      char *nstore = (char *) alloca (strlen (temp) + 3);
3734
 
3735
      startp = endp = temp;
3736
      while (1)
3737
        {
3738
          if (*endp == PATH_SEPARATOR || *endp == 0)
3739
            {
3740
              strncpy (nstore, startp, endp - startp);
3741
              if (endp == startp)
3742
                strcpy (nstore, concat (".", dir_separator_str, NULL));
3743
              else if (!IS_DIR_SEPARATOR (endp[-1]))
3744
                {
3745
                  nstore[endp - startp] = DIR_SEPARATOR;
3746
                  nstore[endp - startp + 1] = 0;
3747
                }
3748
              else
3749
                nstore[endp - startp] = 0;
3750
              add_prefix (&startfile_prefixes, nstore, NULL,
3751
                          PREFIX_PRIORITY_LAST, 0, 1);
3752
              if (*endp == 0)
3753
                break;
3754
              endp = startp = endp + 1;
3755
            }
3756
          else
3757
            endp++;
3758
        }
3759
    }
3760
 
3761
  /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3762
  GET_ENVIRONMENT (temp, "LPATH");
3763
  if (temp && *cross_compile == '0')
3764
    {
3765
      const char *startp, *endp;
3766
      char *nstore = (char *) alloca (strlen (temp) + 3);
3767
 
3768
      startp = endp = temp;
3769
      while (1)
3770
        {
3771
          if (*endp == PATH_SEPARATOR || *endp == 0)
3772
            {
3773
              strncpy (nstore, startp, endp - startp);
3774
              if (endp == startp)
3775
                strcpy (nstore, concat (".", dir_separator_str, NULL));
3776
              else if (!IS_DIR_SEPARATOR (endp[-1]))
3777
                {
3778
                  nstore[endp - startp] = DIR_SEPARATOR;
3779
                  nstore[endp - startp + 1] = 0;
3780
                }
3781
              else
3782
                nstore[endp - startp] = 0;
3783
              add_prefix (&startfile_prefixes, nstore, NULL,
3784
                          PREFIX_PRIORITY_LAST, 0, 1);
3785
              if (*endp == 0)
3786
                break;
3787
              endp = startp = endp + 1;
3788
            }
3789
          else
3790
            endp++;
3791
        }
3792
    }
3793
 
3794
  /* Scan argv twice.  Here, the first time, just count how many switches
3795
     there will be in their vector, and how many input files in theirs.
3796
     Here we also parse the switches that cc itself uses (e.g. -v).  */
3797
 
3798
  for (i = 1; i < argc; i++)
3799
    {
3800
      if (! strcmp (argv[i], "-dumpspecs"))
3801
        {
3802
          struct spec_list *sl;
3803
          init_spec ();
3804
          for (sl = specs; sl; sl = sl->next)
3805
            printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3806
          if (link_command_spec)
3807
            printf ("*link_command:\n%s\n\n", link_command_spec);
3808
          exit (0);
3809
        }
3810
      else if (! strcmp (argv[i], "-dumpversion"))
3811
        {
3812
          printf ("%s\n", spec_version);
3813
          exit (0);
3814
        }
3815
      else if (! strcmp (argv[i], "-dumpmachine"))
3816
        {
3817
          printf ("%s\n", spec_machine);
3818
          exit (0);
3819
        }
3820
      else if (strcmp (argv[i], "-fversion") == 0)
3821
        {
3822
          /* translate_options () has turned --version into -fversion.  */
3823
          print_version = 1;
3824
 
3825
          /* We will be passing a dummy file on to the sub-processes.  */
3826
          n_infiles++;
3827
          n_switches++;
3828
 
3829
          /* CPP driver cannot obtain switch from cc1_options.  */
3830
          if (is_cpp_driver)
3831
            add_preprocessor_option ("--version", strlen ("--version"));
3832
          add_assembler_option ("--version", strlen ("--version"));
3833
          add_linker_option ("--version", strlen ("--version"));
3834
        }
3835
      else if (strcmp (argv[i], "-fhelp") == 0)
3836
        {
3837
          /* translate_options () has turned --help into -fhelp.  */
3838
          print_help_list = 1;
3839
 
3840
          /* We will be passing a dummy file on to the sub-processes.  */
3841
          n_infiles++;
3842
          n_switches++;
3843
 
3844
          /* CPP driver cannot obtain switch from cc1_options.  */
3845
          if (is_cpp_driver)
3846
            add_preprocessor_option ("--help", 6);
3847
          add_assembler_option ("--help", 6);
3848
          add_linker_option ("--help", 6);
3849
        }
3850
      else if (strncmp (argv[i], "-fhelp=", 7) == 0)
3851
        {
3852
          /* translate_options () has turned --help into -fhelp.  */
3853
          print_subprocess_help = 2;
3854
 
3855
          /* We will be passing a dummy file on to the sub-processes.  */
3856
          n_infiles++;
3857
          n_switches++;
3858
        }
3859
      else if (strcmp (argv[i], "-ftarget-help") == 0)
3860
        {
3861
          /* translate_options() has turned --target-help into -ftarget-help.  */
3862
          print_subprocess_help = 1;
3863
 
3864
          /* We will be passing a dummy file on to the sub-processes.  */
3865
          n_infiles++;
3866
          n_switches++;
3867
 
3868
          /* CPP driver cannot obtain switch from cc1_options.  */
3869
          if (is_cpp_driver)
3870
            add_preprocessor_option ("--target-help", 13);
3871
          add_assembler_option ("--target-help", 13);
3872
          add_linker_option ("--target-help", 13);
3873
        }
3874
      else if (! strcmp (argv[i], "-pass-exit-codes"))
3875
        {
3876
          pass_exit_codes = 1;
3877
          n_switches++;
3878
        }
3879
      else if (! strcmp (argv[i], "-print-search-dirs"))
3880
        print_search_dirs = 1;
3881
      else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3882
        print_file_name = "libgcc.a";
3883
      else if (! strncmp (argv[i], "-print-file-name=", 17))
3884
        print_file_name = argv[i] + 17;
3885
      else if (! strncmp (argv[i], "-print-prog-name=", 17))
3886
        print_prog_name = argv[i] + 17;
3887
      else if (! strcmp (argv[i], "-print-multi-lib"))
3888
        print_multi_lib = 1;
3889
      else if (! strcmp (argv[i], "-print-multi-directory"))
3890
        print_multi_directory = 1;
3891
      else if (! strcmp (argv[i], "-print-sysroot"))
3892
        print_sysroot = 1;
3893
      else if (! strcmp (argv[i], "-print-multi-os-directory"))
3894
        print_multi_os_directory = 1;
3895
      else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
3896
        print_sysroot_headers_suffix = 1;
3897
      else if (! strcmp (argv[i], "-fcompare-debug-second"))
3898
        {
3899
          compare_debug_second = 1;
3900
          n_switches++;
3901
        }
3902
      else if (! strcmp (argv[i], "-fno-compare-debug"))
3903
        {
3904
          argv[i] = "-fcompare-debug=";
3905
          goto compare_debug_with_arg;
3906
        }
3907
      else if (! strcmp (argv[i], "-fcompare-debug"))
3908
        {
3909
          argv[i] = "-fcompare-debug=-gtoggle";
3910
          goto compare_debug_with_arg;
3911
        }
3912
#define OPT "-fcompare-debug="
3913
      else if (! strncmp (argv[i], OPT, sizeof (OPT) - 1))
3914
        {
3915
          const char *opt;
3916
        compare_debug_with_arg:
3917
          opt = argv[i] + sizeof (OPT) - 1;
3918
#undef OPT
3919
          if (*opt)
3920
            compare_debug = 1;
3921
          else
3922
            compare_debug = -1;
3923
          if (compare_debug < 0)
3924
            compare_debug_opt = NULL;
3925
          else
3926
            compare_debug_opt = opt;
3927
          n_switches++;
3928
        }
3929
      else if (! strncmp (argv[i], "-Wa,", 4))
3930
        {
3931
          int prev, j;
3932
          /* Pass the rest of this option to the assembler.  */
3933
 
3934
          /* Split the argument at commas.  */
3935
          prev = 4;
3936
          for (j = 4; argv[i][j]; j++)
3937
            if (argv[i][j] == ',')
3938
              {
3939
                add_assembler_option (argv[i] + prev, j - prev);
3940
                prev = j + 1;
3941
              }
3942
 
3943
          /* Record the part after the last comma.  */
3944
          add_assembler_option (argv[i] + prev, j - prev);
3945
        }
3946
      else if (! strncmp (argv[i], "-Wp,", 4))
3947
        {
3948
          int prev, j;
3949
          /* Pass the rest of this option to the preprocessor.  */
3950
 
3951
          /* Split the argument at commas.  */
3952
          prev = 4;
3953
          for (j = 4; argv[i][j]; j++)
3954
            if (argv[i][j] == ',')
3955
              {
3956
                add_preprocessor_option (argv[i] + prev, j - prev);
3957
                prev = j + 1;
3958
              }
3959
 
3960
          /* Record the part after the last comma.  */
3961
          add_preprocessor_option (argv[i] + prev, j - prev);
3962
        }
3963
      else if (argv[i][0] == '+' && argv[i][1] == 'e')
3964
        /* The +e options to the C++ front-end.  */
3965
        n_switches++;
3966
      else if (strncmp (argv[i], "-Wl,", 4) == 0)
3967
        {
3968
          int j;
3969
          /* Split the argument at commas.  */
3970
          for (j = 3; argv[i][j]; j++)
3971
            n_infiles += (argv[i][j] == ',');
3972
        }
3973
      else if (strcmp (argv[i], "-Xlinker") == 0)
3974
        {
3975
          if (i + 1 == argc)
3976
            fatal ("argument to '-Xlinker' is missing");
3977
 
3978
          n_infiles++;
3979
          i++;
3980
        }
3981
      else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3982
        {
3983
          if (i + 1 == argc)
3984
            fatal ("argument to '-Xpreprocessor' is missing");
3985
 
3986
          add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3987
        }
3988
      else if (strcmp (argv[i], "-Xassembler") == 0)
3989
        {
3990
          if (i + 1 == argc)
3991
            fatal ("argument to '-Xassembler' is missing");
3992
 
3993
          add_assembler_option (argv[i+1], strlen (argv[i+1]));
3994
        }
3995
      else if (strcmp (argv[i], "-l") == 0)
3996
        {
3997
          if (i + 1 == argc)
3998
            fatal ("argument to '-l' is missing");
3999
 
4000
          n_infiles++;
4001
          i++;
4002
        }
4003
      else if (strncmp (argv[i], "-l", 2) == 0)
4004
        n_infiles++;
4005
      else if (strcmp (argv[i], "-save-temps") == 0)
4006
        {
4007
          save_temps_flag = SAVE_TEMPS_CWD;
4008
          n_switches++;
4009
        }
4010
      else if (strncmp (argv[i], "-save-temps=", 12) == 0)
4011
        {
4012
          n_switches++;
4013
          if (strcmp (argv[i]+12, "cwd") == 0)
4014
            save_temps_flag = SAVE_TEMPS_CWD;
4015
          else if (strcmp (argv[i]+12, "obj") == 0
4016
                   || strcmp (argv[i]+12, "object") == 0)
4017
            save_temps_flag = SAVE_TEMPS_OBJ;
4018
          else
4019
            fatal ("'%s' is an unknown -save-temps option", argv[i]);
4020
        }
4021
      else if (strcmp (argv[i], "-no-canonical-prefixes") == 0)
4022
        /* Already handled as a special case, so ignored here.  */
4023
        ;
4024
      else if (strcmp (argv[i], "-combine") == 0)
4025
        {
4026
          combine_flag = 1;
4027
          n_switches++;
4028
        }
4029
      else if (strcmp (argv[i], "-specs") == 0)
4030
        {
4031
          struct user_specs *user = XNEW (struct user_specs);
4032
          if (++i >= argc)
4033
            fatal ("argument to '-specs' is missing");
4034
 
4035
          user->next = (struct user_specs *) 0;
4036
          user->filename = argv[i];
4037
          if (user_specs_tail)
4038
            user_specs_tail->next = user;
4039
          else
4040
            user_specs_head = user;
4041
          user_specs_tail = user;
4042
        }
4043
      else if (strncmp (argv[i], "-specs=", 7) == 0)
4044
        {
4045
          struct user_specs *user = XNEW (struct user_specs);
4046
          if (strlen (argv[i]) == 7)
4047
            fatal ("argument to '-specs=' is missing");
4048
 
4049
          user->next = (struct user_specs *) 0;
4050
          user->filename = argv[i] + 7;
4051
          if (user_specs_tail)
4052
            user_specs_tail->next = user;
4053
          else
4054
            user_specs_head = user;
4055
          user_specs_tail = user;
4056
        }
4057
      else if (strcmp (argv[i], "-time") == 0)
4058
        report_times = 1;
4059
      else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4060
        {
4061
          if (report_times_to_file)
4062
            fclose (report_times_to_file);
4063
          report_times_to_file = fopen (argv[i] + sizeof ("-time=") - 1, "a");
4064
        }
4065
      else if (strcmp (argv[i], "-pipe") == 0)
4066
        {
4067
          /* -pipe has to go into the switches array as well as
4068
             setting a flag.  */
4069
          use_pipes = 1;
4070
          n_switches++;
4071
        }
4072
      else if (strcmp (argv[i], "-wrapper") == 0)
4073
        {
4074
          if (++i >= argc)
4075
            fatal ("argument to '-wrapper' is missing");
4076
 
4077
          wrapper_string = argv[i];
4078
          n_switches++;
4079
          n_switches++;
4080
        }
4081
      else if (strcmp (argv[i], "-###") == 0)
4082
        {
4083
          /* This is similar to -v except that there is no execution
4084
             of the commands and the echoed arguments are quoted.  It
4085
             is intended for use in shell scripts to capture the
4086
             driver-generated command line.  */
4087
          verbose_only_flag++;
4088
          verbose_flag++;
4089
        }
4090
      else if (argv[i][0] == '-' && argv[i][1] != 0)
4091
        {
4092
          const char *p = &argv[i][1];
4093
          int c = *p;
4094
 
4095
          switch (c)
4096
            {
4097
            case 'b':
4098
              if (p[1] && NULL == strchr (argv[i] + 2, '-'))
4099
                goto normal_switch;
4100
 
4101
              /* Fall through.  */
4102
            case 'V':
4103
              fatal ("'-%c' must come at the start of the command line", c);
4104
              break;
4105
 
4106
            case 'B':
4107
              {
4108
                const char *value;
4109
                int len;
4110
 
4111
                if (p[1] == 0 && i + 1 == argc)
4112
                  fatal ("argument to '-B' is missing");
4113
                if (p[1] == 0)
4114
                  value = argv[++i];
4115
                else
4116
                  value = p + 1;
4117
 
4118
                len = strlen (value);
4119
 
4120
                /* Catch the case where the user has forgotten to append a
4121
                   directory separator to the path.  Note, they may be using
4122
                   -B to add an executable name prefix, eg "i386-elf-", in
4123
                   order to distinguish between multiple installations of
4124
                   GCC in the same directory.  Hence we must check to see
4125
                   if appending a directory separator actually makes a
4126
                   valid directory name.  */
4127
                if (! IS_DIR_SEPARATOR (value [len - 1])
4128
                    && is_directory (value, false))
4129
                  {
4130
                    char *tmp = XNEWVEC (char, len + 2);
4131
                    strcpy (tmp, value);
4132
                    tmp[len] = DIR_SEPARATOR;
4133
                    tmp[++ len] = 0;
4134
                    value = tmp;
4135
                  }
4136
 
4137
                add_prefix (&exec_prefixes, value, NULL,
4138
                            PREFIX_PRIORITY_B_OPT, 0, 0);
4139
                add_prefix (&startfile_prefixes, value, NULL,
4140
                            PREFIX_PRIORITY_B_OPT, 0, 0);
4141
                add_prefix (&include_prefixes, value, NULL,
4142
                            PREFIX_PRIORITY_B_OPT, 0, 0);
4143
                n_switches++;
4144
              }
4145
              break;
4146
 
4147
            case 'v':   /* Print our subcommands and print versions.  */
4148
              n_switches++;
4149
              /* If they do anything other than exactly `-v', don't set
4150
                 verbose_flag; rather, continue on to give the error.  */
4151
              if (p[1] != 0)
4152
                break;
4153
              verbose_flag++;
4154
              break;
4155
 
4156
            case 'S':
4157
            case 'c':
4158
            case 'E':
4159
              if (p[1] == 0)
4160
                {
4161
                  have_c = 1;
4162
                  n_switches++;
4163
                  break;
4164
                }
4165
              goto normal_switch;
4166
 
4167
            case 'o':
4168
              have_o = 1;
4169
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
4170
              if (! have_c)
4171
                {
4172
                  int skip;
4173
 
4174
                  /* Forward scan, just in case -S, -E or -c is specified
4175
                     after -o.  */
4176
                  int j = i + 1;
4177
                  if (p[1] == 0)
4178
                    ++j;
4179
                  while (j < argc)
4180
                    {
4181
                      if (argv[j][0] == '-')
4182
                        {
4183
                          if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
4184
                              && argv[j][2] == 0)
4185
                            {
4186
                              have_c = 1;
4187
                              break;
4188
                            }
4189
                          else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
4190
                            j += skip - (argv[j][2] != 0);
4191
                          else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
4192
                            j += skip;
4193
                        }
4194
                      j++;
4195
                    }
4196
                }
4197
#endif
4198
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4199
              if (p[1] == 0)
4200
                argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
4201
              else
4202
                argv[i] = convert_filename (argv[i], ! have_c, 0);
4203
#endif
4204
              /* Save the output name in case -save-temps=obj was used.  */
4205
              if ((p[1] == 0) && argv[i + 1])
4206
                save_temps_prefix = xstrdup(argv[i + 1]);
4207
              else
4208
                save_temps_prefix = xstrdup(argv[i] + 1);
4209
              goto normal_switch;
4210
 
4211
            default:
4212
            normal_switch:
4213
 
4214
#ifdef MODIFY_TARGET_NAME
4215
              is_modify_target_name = 0;
4216
 
4217
              for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4218
                if (! strcmp (argv[i], modify_target[j].sw))
4219
                  {
4220
                    char *new_name = XNEWVEC (char, strlen (modify_target[j].str)
4221
                                              + strlen (spec_machine));
4222
                    const char *p, *r;
4223
                    char *q;
4224
                    int made_addition = 0;
4225
 
4226
                    is_modify_target_name = 1;
4227
                    for (p = spec_machine, q = new_name; *p != 0; )
4228
                      {
4229
                        if (modify_target[j].add_del == DELETE
4230
                            && (! strncmp (q, modify_target[j].str,
4231
                                           strlen (modify_target[j].str))))
4232
                          p += strlen (modify_target[j].str);
4233
                        else if (modify_target[j].add_del == ADD
4234
                                 && ! made_addition && *p == '-')
4235
                          {
4236
                            for (r = modify_target[j].str; *r != 0; )
4237
                              *q++ = *r++;
4238
                            made_addition = 1;
4239
                          }
4240
 
4241
                        *q++ = *p++;
4242
                      }
4243
 
4244
                    spec_machine = new_name;
4245
                  }
4246
 
4247
              if (is_modify_target_name)
4248
                break;
4249
#endif
4250
 
4251
              n_switches++;
4252
 
4253
              if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
4254
                i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
4255
              else if (WORD_SWITCH_TAKES_ARG (p))
4256
                i += WORD_SWITCH_TAKES_ARG (p);
4257
            }
4258
        }
4259
      else
4260
        {
4261
          n_infiles++;
4262
          lang_n_infiles++;
4263
        }
4264
    }
4265
 
4266
  /* If -save-temps=obj and -o name, create the prefix to use for %b.
4267
     Otherwise just make -save-temps=obj the same as -save-temps=cwd.  */
4268
  if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4269
    {
4270
      save_temps_length = strlen (save_temps_prefix);
4271
      temp = strrchr (lbasename (save_temps_prefix), '.');
4272
      if (temp)
4273
        {
4274
          save_temps_length -= strlen (temp);
4275
          save_temps_prefix[save_temps_length] = '\0';
4276
        }
4277
 
4278
    }
4279
  else if (save_temps_prefix != NULL)
4280
    {
4281
      free (save_temps_prefix);
4282
      save_temps_prefix = NULL;
4283
    }
4284
 
4285
  if (save_temps_flag && use_pipes)
4286
    {
4287
      /* -save-temps overrides -pipe, so that temp files are produced */
4288
      if (save_temps_flag)
4289
        error ("warning: -pipe ignored because -save-temps specified");
4290
      use_pipes = 0;
4291
    }
4292
 
4293
  if (!compare_debug)
4294
    {
4295
      const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4296
 
4297
      if (gcd && gcd[0] == '-')
4298
        {
4299
          compare_debug = 2;
4300
          compare_debug_opt = gcd;
4301
          n_switches++;
4302
        }
4303
      else if (gcd && *gcd && strcmp (gcd, "0"))
4304
        {
4305
          compare_debug = 3;
4306
          compare_debug_opt = "-gtoggle";
4307
          n_switches++;
4308
        }
4309
    }
4310
  else if (compare_debug < 0)
4311
    {
4312
      compare_debug = 0;
4313
      gcc_assert (!compare_debug_opt);
4314
    }
4315
 
4316
  /* Set up the search paths.  We add directories that we expect to
4317
     contain GNU Toolchain components before directories specified by
4318
     the machine description so that we will find GNU components (like
4319
     the GNU assembler) before those of the host system.  */
4320
 
4321
  /* If we don't know where the toolchain has been installed, use the
4322
     configured-in locations.  */
4323
  if (!gcc_exec_prefix)
4324
    {
4325
#ifndef OS2
4326
      add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4327
                  PREFIX_PRIORITY_LAST, 1, 0);
4328
      add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4329
                  PREFIX_PRIORITY_LAST, 2, 0);
4330
      add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4331
                  PREFIX_PRIORITY_LAST, 2, 0);
4332
#endif
4333
      add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4334
                  PREFIX_PRIORITY_LAST, 1, 0);
4335
    }
4336
 
4337
  gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4338
  tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
4339
                           dir_separator_str, NULL);
4340
 
4341
  /* Look for tools relative to the location from which the driver is
4342
     running, or, if that is not available, the configured prefix.  */
4343
  tooldir_prefix
4344
    = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4345
              spec_machine, dir_separator_str,
4346
              spec_version, dir_separator_str, tooldir_prefix, NULL);
4347
 
4348
  add_prefix (&exec_prefixes,
4349
              concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4350
              "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4351
  add_prefix (&startfile_prefixes,
4352
              concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4353
              "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4354
 
4355
#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4356
  /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4357
     then consider it to relocate with the rest of the GCC installation
4358
     if GCC_EXEC_PREFIX is set.
4359
     ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
4360
  if (target_system_root && gcc_exec_prefix)
4361
    {
4362
      char *tmp_prefix = get_relative_prefix (argv[0],
4363
                                              standard_bindir_prefix,
4364
                                              target_system_root);
4365
      if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4366
        {
4367
          target_system_root = tmp_prefix;
4368
          target_system_root_changed = 1;
4369
        }
4370
    }
4371
#endif
4372
 
4373
  /* More prefixes are enabled in main, after we read the specs file
4374
     and determine whether this is cross-compilation or not.  */
4375
 
4376
  /* Then create the space for the vectors and scan again.  */
4377
 
4378
  switches = XNEWVEC (struct switchstr, n_switches + 1);
4379
  infiles = XNEWVEC (struct infile, n_infiles + 1);
4380
  n_switches = 0;
4381
  n_infiles = 0;
4382
  last_language_n_infiles = -1;
4383
 
4384
  /* This, time, copy the text of each switch and store a pointer
4385
     to the copy in the vector of switches.
4386
     Store all the infiles in their vector.  */
4387
 
4388
  for (i = 1; i < argc; i++)
4389
    {
4390
      /* Just skip the switches that were handled by the preceding loop.  */
4391
#ifdef MODIFY_TARGET_NAME
4392
      is_modify_target_name = 0;
4393
 
4394
      for (j = 0; j < ARRAY_SIZE (modify_target); j++)
4395
        if (! strcmp (argv[i], modify_target[j].sw))
4396
          is_modify_target_name = 1;
4397
 
4398
      if (is_modify_target_name)
4399
        ;
4400
      else
4401
#endif
4402
      if (! strncmp (argv[i], "-Wa,", 4))
4403
        ;
4404
      else if (! strncmp (argv[i], "-Wp,", 4))
4405
        ;
4406
      else if (! strcmp (argv[i], "-no-canonical-prefixes"))
4407
        ;
4408
      else if (! strcmp (argv[i], "-pass-exit-codes"))
4409
        ;
4410
      else if (! strcmp (argv[i], "-print-search-dirs"))
4411
        ;
4412
      else if (! strcmp (argv[i], "-print-libgcc-file-name"))
4413
        ;
4414
      else if (! strncmp (argv[i], "-print-file-name=", 17))
4415
        ;
4416
      else if (! strncmp (argv[i], "-print-prog-name=", 17))
4417
        ;
4418
      else if (! strcmp (argv[i], "-print-multi-lib"))
4419
        ;
4420
      else if (! strcmp (argv[i], "-print-multi-directory"))
4421
        ;
4422
      else if (! strcmp (argv[i], "-print-sysroot"))
4423
        ;
4424
      else if (! strcmp (argv[i], "-print-multi-os-directory"))
4425
        ;
4426
      else if (! strcmp (argv[i], "-print-sysroot-headers-suffix"))
4427
        ;
4428
      else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
4429
        {
4430
          target_system_root = argv[i] + strlen ("--sysroot=");
4431
          target_system_root_changed = 1;
4432
        }
4433
      else if (argv[i][0] == '+' && argv[i][1] == 'e')
4434
        {
4435
          /* Compensate for the +e options to the C++ front-end;
4436
             they're there simply for cfront call-compatibility.  We do
4437
             some magic in default_compilers to pass them down properly.
4438
             Note we deliberately start at the `+' here, to avoid passing
4439
             -e0 or -e1 down into the linker.  */
4440
          switches[n_switches].part1 = &argv[i][0];
4441
          switches[n_switches].args = 0;
4442
          switches[n_switches].live_cond = 0;
4443
          switches[n_switches].validated = 0;
4444
          n_switches++;
4445
        }
4446
      else if (strncmp (argv[i], "-Wl,", 4) == 0)
4447
        {
4448
          int prev, j;
4449
          /* Split the argument at commas.  */
4450
          prev = 4;
4451
          for (j = 4; argv[i][j]; j++)
4452
            if (argv[i][j] == ',')
4453
              {
4454
                infiles[n_infiles].language = "*";
4455
                infiles[n_infiles++].name
4456
                  = save_string (argv[i] + prev, j - prev);
4457
                prev = j + 1;
4458
              }
4459
          /* Record the part after the last comma.  */
4460
          infiles[n_infiles].language = "*";
4461
          infiles[n_infiles++].name = argv[i] + prev;
4462
        }
4463
      else if (strcmp (argv[i], "-Xlinker") == 0)
4464
        {
4465
          infiles[n_infiles].language = "*";
4466
          infiles[n_infiles++].name = argv[++i];
4467
        }
4468
      /* Xassembler and Xpreprocessor were already handled in the first argv
4469
         scan, so all we need to do here is ignore them and their argument.  */
4470
      else if (strcmp (argv[i], "-Xassembler") == 0)
4471
        i++;
4472
      else if (strcmp (argv[i], "-Xpreprocessor") == 0)
4473
        i++;
4474
      else if (strcmp (argv[i], "-l") == 0)
4475
        { /* POSIX allows separation of -l and the lib arg;
4476
             canonicalize by concatenating -l with its arg */
4477
          infiles[n_infiles].language = "*";
4478
          infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
4479
        }
4480
      else if (strncmp (argv[i], "-l", 2) == 0)
4481
        {
4482
          infiles[n_infiles].language = "*";
4483
          infiles[n_infiles++].name = argv[i];
4484
        }
4485
      else if (strcmp (argv[i], "-wrapper") == 0)
4486
        i++;
4487
      else if (strcmp (argv[i], "-specs") == 0)
4488
        i++;
4489
      else if (strncmp (argv[i], "-specs=", 7) == 0)
4490
        ;
4491
      else if (strcmp (argv[i], "-time") == 0)
4492
        ;
4493
      else if (strncmp (argv[i], "-time=", sizeof ("-time=") - 1) == 0)
4494
        ;
4495
      else if (strcmp (argv[i], "-###") == 0)
4496
        ;
4497
      else if (argv[i][0] == '-' && argv[i][1] != 0)
4498
        {
4499
          const char *p = &argv[i][1];
4500
          int c = *p;
4501
 
4502
          if (c == 'x')
4503
            {
4504
              if (p[1] == 0 && i + 1 == argc)
4505
                fatal ("argument to '-x' is missing");
4506
              if (p[1] == 0)
4507
                spec_lang = argv[++i];
4508
              else
4509
                spec_lang = p + 1;
4510
              if (! strcmp (spec_lang, "none"))
4511
                /* Suppress the warning if -xnone comes after the last input
4512
                   file, because alternate command interfaces like g++ might
4513
                   find it useful to place -xnone after each input file.  */
4514
                spec_lang = 0;
4515
              else
4516
                last_language_n_infiles = n_infiles;
4517
              continue;
4518
            }
4519
          switches[n_switches].part1 = p;
4520
          /* Deal with option arguments in separate argv elements.  */
4521
          if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4522
              || WORD_SWITCH_TAKES_ARG (p))
4523
            {
4524
              int j = 0;
4525
              int n_args = WORD_SWITCH_TAKES_ARG (p);
4526
 
4527
              if (n_args == 0)
4528
                {
4529
                  /* Count only the option arguments in separate argv elements.  */
4530
                  n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4531
                }
4532
              if (i + n_args >= argc)
4533
                fatal ("argument to '-%s' is missing", p);
4534
              switches[n_switches].args
4535
                = XNEWVEC (const char *, n_args + 1);
4536
              while (j < n_args)
4537
                switches[n_switches].args[j++] = argv[++i];
4538
              /* Null-terminate the vector.  */
4539
              switches[n_switches].args[j] = 0;
4540
            }
4541
          else if (strchr (switches_need_spaces, c))
4542
            {
4543
              /* On some systems, ld cannot handle some options without
4544
                 a space.  So split the option from its argument.  */
4545
              char *part1 = XNEWVEC (char, 2);
4546
              part1[0] = c;
4547
              part1[1] = '\0';
4548
 
4549
              switches[n_switches].part1 = part1;
4550
              switches[n_switches].args = XNEWVEC (const char *, 2);
4551
              switches[n_switches].args[0] = xstrdup (p+1);
4552
              switches[n_switches].args[1] = 0;
4553
            }
4554
          else
4555
            switches[n_switches].args = 0;
4556
 
4557
          switches[n_switches].live_cond = 0;
4558
          switches[n_switches].validated = 0;
4559
          switches[n_switches].ordering = 0;
4560
          /* These are always valid, since gcc.c itself understands the
4561
             first four and gfortranspec.c understands -static-libgfortran.  */
4562
          if (!strcmp (p, "save-temps")
4563
              || !strcmp (p, "static-libgcc")
4564
              || !strcmp (p, "shared-libgcc")
4565
              || !strcmp (p, "pipe")
4566
              || !strcmp (p, "static-libgfortran"))
4567
            switches[n_switches].validated = 1;
4568
          else
4569
            {
4570
              char ch = switches[n_switches].part1[0];
4571
              if (ch == 'B')
4572
                switches[n_switches].validated = 1;
4573
            }
4574
          n_switches++;
4575
        }
4576
      else
4577
        {
4578
          const char *p = strrchr (argv[i], '@');
4579
          char *fname;
4580
          long offset;
4581
          int consumed;
4582
#ifdef HAVE_TARGET_OBJECT_SUFFIX
4583
          argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4584
#endif
4585
          /* For LTO static archive support we handle input file
4586
             specifications that are composed of a filename and
4587
             an offset like FNAME@OFFSET.  */
4588
          if (p
4589
              && p != argv[i]
4590
              && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4591
              && strlen (p) == (unsigned int)consumed)
4592
            {
4593
              fname = (char *)xmalloc (p - argv[i] + 1);
4594
              memcpy (fname, argv[i], p - argv[i]);
4595
              fname[p - argv[i]] = '\0';
4596
              /* Only accept non-stdin and existing FNAME parts, otherwise
4597
                 try with the full name.  */
4598
              if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4599
                {
4600
                  free (fname);
4601
                  fname = xstrdup (argv[i]);
4602
                }
4603
            }
4604
          else
4605
            fname = xstrdup (argv[i]);
4606
 
4607
          if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4608
            {
4609
              perror_with_name (fname);
4610
              error_count++;
4611
            }
4612
          else
4613
            {
4614
              infiles[n_infiles].language = spec_lang;
4615
              infiles[n_infiles++].name = argv[i];
4616
            }
4617
 
4618
          free (fname);
4619
        }
4620
    }
4621
 
4622
  if (n_infiles == last_language_n_infiles && spec_lang != 0)
4623
    error ("warning: '-x %s' after last input file has no effect", spec_lang);
4624
 
4625
  if (compare_debug == 2 || compare_debug == 3)
4626
    {
4627
      switches[n_switches].part1 = concat ("fcompare-debug=",
4628
                                           compare_debug_opt,
4629
                                           NULL);
4630
      switches[n_switches].args = 0;
4631
      switches[n_switches].live_cond = 0;
4632
      switches[n_switches].validated = 0;
4633
      switches[n_switches].ordering = 0;
4634
      n_switches++;
4635
      compare_debug = 1;
4636
    }
4637
 
4638
  /* Ensure we only invoke each subprocess once.  */
4639
  if (print_subprocess_help || print_help_list || print_version)
4640
    {
4641
      n_infiles = 1;
4642
 
4643
      /* Create a dummy input file, so that we can pass
4644
         the help option on to the various sub-processes.  */
4645
      infiles[0].language = "c";
4646
      infiles[0].name   = "help-dummy";
4647
    }
4648
 
4649
  switches[n_switches].part1 = 0;
4650
  infiles[n_infiles].name = 0;
4651
}
4652
 
4653
/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4654
   and place that in the environment.  */
4655
 
4656
static void
4657
set_collect_gcc_options (void)
4658
{
4659
  int i;
4660
  int first_time;
4661
 
4662
  /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4663
     the compiler.  */
4664
  obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4665
                sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4666
 
4667
  first_time = TRUE;
4668
  for (i = 0; (int) i < n_switches; i++)
4669
    {
4670
      const char *const *args;
4671
      const char *p, *q;
4672
      if (!first_time)
4673
        obstack_grow (&collect_obstack, " ", 1);
4674
 
4675
      first_time = FALSE;
4676
 
4677
      /* Ignore elided switches.  */
4678
      if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
4679
        continue;
4680
 
4681
      obstack_grow (&collect_obstack, "'-", 2);
4682
      q = switches[i].part1;
4683
      while ((p = strchr (q, '\'')))
4684
        {
4685
          obstack_grow (&collect_obstack, q, p - q);
4686
          obstack_grow (&collect_obstack, "'\\''", 4);
4687
          q = ++p;
4688
        }
4689
      obstack_grow (&collect_obstack, q, strlen (q));
4690
      obstack_grow (&collect_obstack, "'", 1);
4691
 
4692
      for (args = switches[i].args; args && *args; args++)
4693
        {
4694
          obstack_grow (&collect_obstack, " '", 2);
4695
          q = *args;
4696
          while ((p = strchr (q, '\'')))
4697
            {
4698
              obstack_grow (&collect_obstack, q, p - q);
4699
              obstack_grow (&collect_obstack, "'\\''", 4);
4700
              q = ++p;
4701
            }
4702
          obstack_grow (&collect_obstack, q, strlen (q));
4703
          obstack_grow (&collect_obstack, "'", 1);
4704
        }
4705
    }
4706
  obstack_grow (&collect_obstack, "\0", 1);
4707
  xputenv (XOBFINISH (&collect_obstack, char *));
4708
}
4709
 
4710
/* Process a spec string, accumulating and running commands.  */
4711
 
4712
/* These variables describe the input file name.
4713
   input_file_number is the index on outfiles of this file,
4714
   so that the output file name can be stored for later use by %o.
4715
   input_basename is the start of the part of the input file
4716
   sans all directory names, and basename_length is the number
4717
   of characters starting there excluding the suffix .c or whatever.  */
4718
 
4719
static const char *input_filename;
4720
static int input_file_number;
4721
size_t input_filename_length;
4722
static int basename_length;
4723
static int suffixed_basename_length;
4724
static const char *input_basename;
4725
static const char *input_suffix;
4726
#ifndef HOST_LACKS_INODE_NUMBERS
4727
static struct stat input_stat;
4728
#endif
4729
static int input_stat_set;
4730
 
4731
/* The compiler used to process the current input file.  */
4732
static struct compiler *input_file_compiler;
4733
 
4734
/* These are variables used within do_spec and do_spec_1.  */
4735
 
4736
/* Nonzero if an arg has been started and not yet terminated
4737
   (with space, tab or newline).  */
4738
static int arg_going;
4739
 
4740
/* Nonzero means %d or %g has been seen; the next arg to be terminated
4741
   is a temporary file name.  */
4742
static int delete_this_arg;
4743
 
4744
/* Nonzero means %w has been seen; the next arg to be terminated
4745
   is the output file name of this compilation.  */
4746
static int this_is_output_file;
4747
 
4748
/* Nonzero means %s has been seen; the next arg to be terminated
4749
   is the name of a library file and we should try the standard
4750
   search dirs for it.  */
4751
static int this_is_library_file;
4752
 
4753
/* Nonzero means %T has been seen; the next arg to be terminated
4754
   is the name of a linker script and we should try all of the
4755
   standard search dirs for it.  If it is found insert a --script
4756
   command line switch and then substitute the full path in place,
4757
   otherwise generate an error message.  */
4758
static int this_is_linker_script;
4759
 
4760
/* Nonzero means that the input of this command is coming from a pipe.  */
4761
static int input_from_pipe;
4762
 
4763
/* Nonnull means substitute this for any suffix when outputting a switches
4764
   arguments.  */
4765
static const char *suffix_subst;
4766
 
4767
/* If there is an argument being accumulated, terminate it and store it.  */
4768
 
4769
static void
4770
end_going_arg (void)
4771
{
4772
  if (arg_going)
4773
    {
4774
      const char *string;
4775
 
4776
      obstack_1grow (&obstack, 0);
4777
      string = XOBFINISH (&obstack, const char *);
4778
      if (this_is_library_file)
4779
        string = find_file (string);
4780
      if (this_is_linker_script)
4781
        {
4782
          char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4783
 
4784
          if (full_script_path == NULL)
4785
            {
4786
              error (_("unable to locate default linker script '%s' in the library search paths"), string);
4787
              /* Script was not found on search path.  */
4788
              return;
4789
            }
4790
          store_arg ("--script", false, false);
4791
          string = full_script_path;
4792
        }
4793
      store_arg (string, delete_this_arg, this_is_output_file);
4794
      if (this_is_output_file)
4795
        outfiles[input_file_number] = string;
4796
      arg_going = 0;
4797
    }
4798
}
4799
 
4800
 
4801
/* Parse the WRAPPER string which is a comma separated list of the command line
4802
   and insert them into the beginning of argbuf.  */
4803
 
4804
static void
4805
insert_wrapper (const char *wrapper)
4806
{
4807
  int n = 0;
4808
  int i;
4809
  char *buf = xstrdup (wrapper);
4810
  char *p = buf;
4811
 
4812
  do
4813
    {
4814
      n++;
4815
      while (*p == ',')
4816
        p++;
4817
    }
4818
  while ((p = strchr (p, ',')) != NULL);
4819
 
4820
  if (argbuf_index + n >= argbuf_length)
4821
    {
4822
      argbuf_length = argbuf_length * 2;
4823
      while (argbuf_length < argbuf_index + n)
4824
        argbuf_length *= 2;
4825
      argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4826
    }
4827
  for (i = argbuf_index - 1; i >= 0; i--)
4828
    argbuf[i + n] = argbuf[i];
4829
 
4830
  i = 0;
4831
  p = buf;
4832
  do
4833
    {
4834
      while (*p == ',')
4835
        {
4836
          *p = 0;
4837
          p++;
4838
        }
4839
      argbuf[i++] = p;
4840
    }
4841
  while ((p = strchr (p, ',')) != NULL);
4842
  gcc_assert (i == n);
4843
  argbuf_index += n;
4844
}
4845
 
4846
/* Process the spec SPEC and run the commands specified therein.
4847
   Returns 0 if the spec is successfully processed; -1 if failed.  */
4848
 
4849
int
4850
do_spec (const char *spec)
4851
{
4852
  int value;
4853
 
4854
  value = do_spec_2 (spec);
4855
 
4856
  /* Force out any unfinished command.
4857
     If -pipe, this forces out the last command if it ended in `|'.  */
4858
  if (value == 0)
4859
    {
4860
      if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4861
        argbuf_index--;
4862
 
4863
      set_collect_gcc_options ();
4864
 
4865
      if (argbuf_index > 0)
4866
        value = execute ();
4867
    }
4868
 
4869
  return value;
4870
}
4871
 
4872
static int
4873
do_spec_2 (const char *spec)
4874
{
4875
  int result;
4876
 
4877
  clear_args ();
4878
  arg_going = 0;
4879
  delete_this_arg = 0;
4880
  this_is_output_file = 0;
4881
  this_is_library_file = 0;
4882
  this_is_linker_script = 0;
4883
  input_from_pipe = 0;
4884
  suffix_subst = NULL;
4885
 
4886
  result = do_spec_1 (spec, 0, NULL);
4887
 
4888
  end_going_arg ();
4889
 
4890
  return result;
4891
}
4892
 
4893
 
4894
/* Process the given spec string and add any new options to the end
4895
   of the switches/n_switches array.  */
4896
 
4897
static void
4898
do_option_spec (const char *name, const char *spec)
4899
{
4900
  unsigned int i, value_count, value_len;
4901
  const char *p, *q, *value;
4902
  char *tmp_spec, *tmp_spec_p;
4903
 
4904
  if (configure_default_options[0].name == NULL)
4905
    return;
4906
 
4907
  for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4908
    if (strcmp (configure_default_options[i].name, name) == 0)
4909
      break;
4910
  if (i == ARRAY_SIZE (configure_default_options))
4911
    return;
4912
 
4913
  value = configure_default_options[i].value;
4914
  value_len = strlen (value);
4915
 
4916
  /* Compute the size of the final spec.  */
4917
  value_count = 0;
4918
  p = spec;
4919
  while ((p = strstr (p, "%(VALUE)")) != NULL)
4920
    {
4921
      p ++;
4922
      value_count ++;
4923
    }
4924
 
4925
  /* Replace each %(VALUE) by the specified value.  */
4926
  tmp_spec = (char *) alloca (strlen (spec) + 1
4927
                     + value_count * (value_len - strlen ("%(VALUE)")));
4928
  tmp_spec_p = tmp_spec;
4929
  q = spec;
4930
  while ((p = strstr (q, "%(VALUE)")) != NULL)
4931
    {
4932
      memcpy (tmp_spec_p, q, p - q);
4933
      tmp_spec_p = tmp_spec_p + (p - q);
4934
      memcpy (tmp_spec_p, value, value_len);
4935
      tmp_spec_p += value_len;
4936
      q = p + strlen ("%(VALUE)");
4937
    }
4938
  strcpy (tmp_spec_p, q);
4939
 
4940
  do_self_spec (tmp_spec);
4941
}
4942
 
4943
/* Process the given spec string and add any new options to the end
4944
   of the switches/n_switches array.  */
4945
 
4946
static void
4947
do_self_spec (const char *spec)
4948
{
4949
  int i;
4950
 
4951
  do_spec_2 (spec);
4952
  do_spec_1 (" ", 0, NULL);
4953
 
4954
  /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4955
     do_self_specs adds the replacements to switches array, so it shouldn't
4956
     be processed afterwards.  */
4957
  for (i = 0; i < n_switches; i++)
4958
    if ((switches[i].live_cond & SWITCH_IGNORE))
4959
      switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4960
 
4961
  if (argbuf_index > 0)
4962
    {
4963
      switches = XRESIZEVEC (struct switchstr, switches,
4964
                             n_switches + argbuf_index + 1);
4965
 
4966
      for (i = 0; i < argbuf_index; i++)
4967
        {
4968
          struct switchstr *sw;
4969
          const char *p = argbuf[i];
4970
          int c = *p;
4971
 
4972
          /* Each switch should start with '-'.  */
4973
          if (c != '-')
4974
            fatal ("switch '%s' does not start with '-'", argbuf[i]);
4975
 
4976
          p++;
4977
          c = *p;
4978
 
4979
          sw = &switches[n_switches++];
4980
          sw->part1 = p;
4981
          sw->live_cond = 0;
4982
          sw->validated = 0;
4983
          sw->ordering = 0;
4984
 
4985
          /* Deal with option arguments in separate argv elements.  */
4986
          if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4987
              || WORD_SWITCH_TAKES_ARG (p))
4988
            {
4989
              int j = 0;
4990
              int n_args = WORD_SWITCH_TAKES_ARG (p);
4991
 
4992
              if (n_args == 0)
4993
                {
4994
                  /* Count only the option arguments in separate argv elements.  */
4995
                  n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4996
                }
4997
              if (i + n_args >= argbuf_index)
4998
                fatal ("argument to '-%s' is missing", p);
4999
              sw->args
5000
                = XNEWVEC (const char *, n_args + 1);
5001
              while (j < n_args)
5002
                sw->args[j++] = argbuf[++i];
5003
              /* Null-terminate the vector.  */
5004
              sw->args[j] = 0;
5005
            }
5006
          else if (strchr (switches_need_spaces, c))
5007
            {
5008
              /* On some systems, ld cannot handle some options without
5009
                 a space.  So split the option from its argument.  */
5010
              char *part1 = XNEWVEC (char, 2);
5011
              part1[0] = c;
5012
              part1[1] = '\0';
5013
 
5014
              sw->part1 = part1;
5015
              sw->args = XNEWVEC (const char *, 2);
5016
              sw->args[0] = xstrdup (p+1);
5017
              sw->args[1] = 0;
5018
            }
5019
          else
5020
            sw->args = 0;
5021
        }
5022
 
5023
      switches[n_switches].part1 = 0;
5024
    }
5025
}
5026
 
5027
/* Callback for processing %D and %I specs.  */
5028
 
5029
struct spec_path_info {
5030
  const char *option;
5031
  const char *append;
5032
  size_t append_len;
5033
  bool omit_relative;
5034
  bool separate_options;
5035
};
5036
 
5037
static void *
5038
spec_path (char *path, void *data)
5039
{
5040
  struct spec_path_info *info = (struct spec_path_info *) data;
5041
  size_t len = 0;
5042
  char save = 0;
5043
 
5044
  if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
5045
    return NULL;
5046
 
5047
  if (info->append_len != 0)
5048
    {
5049
      len = strlen (path);
5050
      memcpy (path + len, info->append, info->append_len + 1);
5051
    }
5052
 
5053
  if (!is_directory (path, true))
5054
    return NULL;
5055
 
5056
  do_spec_1 (info->option, 1, NULL);
5057
  if (info->separate_options)
5058
    do_spec_1 (" ", 0, NULL);
5059
 
5060
  if (info->append_len == 0)
5061
    {
5062
      len = strlen (path);
5063
      save = path[len - 1];
5064
      if (IS_DIR_SEPARATOR (path[len - 1]))
5065
        path[len - 1] = '\0';
5066
    }
5067
 
5068
  do_spec_1 (path, 1, NULL);
5069
  do_spec_1 (" ", 0, NULL);
5070
 
5071
  /* Must not damage the original path.  */
5072
  if (info->append_len == 0)
5073
    path[len - 1] = save;
5074
 
5075
  return NULL;
5076
}
5077
 
5078
/* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5079
   argument list. */
5080
 
5081
static void
5082
create_at_file (char **argv)
5083
{
5084
  char *temp_file = make_temp_file ("");
5085
  char *at_argument = concat ("@", temp_file, NULL);
5086
  FILE *f = fopen (temp_file, "w");
5087
  int status;
5088
 
5089
  if (f == NULL)
5090
    fatal ("could not open temporary response file %s",
5091
           temp_file);
5092
 
5093
  status = writeargv (argv, f);
5094
 
5095
  if (status)
5096
    fatal ("could not write to temporary response file %s",
5097
           temp_file);
5098
 
5099
  status = fclose (f);
5100
 
5101
  if (EOF == status)
5102
    fatal ("could not close temporary response file %s",
5103
           temp_file);
5104
 
5105
  store_arg (at_argument, 0, 0);
5106
 
5107
  record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5108
}
5109
 
5110
/* True if we should compile INFILE. */
5111
 
5112
static bool
5113
compile_input_file_p (struct infile *infile)
5114
{
5115
  if ((!infile->language) || (infile->language[0] != '*'))
5116
    if (infile->incompiler == input_file_compiler)
5117
      return true;
5118
  return false;
5119
}
5120
 
5121
/* Process the sub-spec SPEC as a portion of a larger spec.
5122
   This is like processing a whole spec except that we do
5123
   not initialize at the beginning and we do not supply a
5124
   newline by default at the end.
5125
   INSWITCH nonzero means don't process %-sequences in SPEC;
5126
   in this case, % is treated as an ordinary character.
5127
   This is used while substituting switches.
5128
   INSWITCH nonzero also causes SPC not to terminate an argument.
5129
 
5130
   Value is zero unless a line was finished
5131
   and the command on that line reported an error.  */
5132
 
5133
static int
5134
do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5135
{
5136
  const char *p = spec;
5137
  int c;
5138
  int i;
5139
  int value;
5140
 
5141
  while ((c = *p++))
5142
    /* If substituting a switch, treat all chars like letters.
5143
       Otherwise, NL, SPC, TAB and % are special.  */
5144
    switch (inswitch ? 'a' : c)
5145
      {
5146
      case '\n':
5147
        end_going_arg ();
5148
 
5149
        if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
5150
          {
5151
            /* A `|' before the newline means use a pipe here,
5152
               but only if -pipe was specified.
5153
               Otherwise, execute now and don't pass the `|' as an arg.  */
5154
            if (use_pipes)
5155
              {
5156
                input_from_pipe = 1;
5157
                break;
5158
              }
5159
            else
5160
              argbuf_index--;
5161
          }
5162
 
5163
        set_collect_gcc_options ();
5164
 
5165
        if (argbuf_index > 0)
5166
          {
5167
            value = execute ();
5168
            if (value)
5169
              return value;
5170
          }
5171
        /* Reinitialize for a new command, and for a new argument.  */
5172
        clear_args ();
5173
        arg_going = 0;
5174
        delete_this_arg = 0;
5175
        this_is_output_file = 0;
5176
        this_is_library_file = 0;
5177
        this_is_linker_script = 0;
5178
        input_from_pipe = 0;
5179
        break;
5180
 
5181
      case '|':
5182
        end_going_arg ();
5183
 
5184
        /* Use pipe */
5185
        obstack_1grow (&obstack, c);
5186
        arg_going = 1;
5187
        break;
5188
 
5189
      case '\t':
5190
      case ' ':
5191
        end_going_arg ();
5192
 
5193
        /* Reinitialize for a new argument.  */
5194
        delete_this_arg = 0;
5195
        this_is_output_file = 0;
5196
        this_is_library_file = 0;
5197
        this_is_linker_script = 0;
5198
        break;
5199
 
5200
      case '%':
5201
        switch (c = *p++)
5202
          {
5203
          case 0:
5204
            fatal ("spec '%s' invalid", spec);
5205
 
5206
          case 'b':
5207
            if (save_temps_length)
5208
              obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5209
            else
5210
              obstack_grow (&obstack, input_basename, basename_length);
5211
            if (compare_debug < 0)
5212
              obstack_grow (&obstack, ".gk", 3);
5213
            arg_going = 1;
5214
            break;
5215
 
5216
          case 'B':
5217
            if (save_temps_length)
5218
              obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5219
            else
5220
              obstack_grow (&obstack, input_basename, suffixed_basename_length);
5221
            if (compare_debug < 0)
5222
              obstack_grow (&obstack, ".gk", 3);
5223
            arg_going = 1;
5224
            break;
5225
 
5226
          case 'd':
5227
            delete_this_arg = 2;
5228
            break;
5229
 
5230
          /* Dump out the directories specified with LIBRARY_PATH,
5231
             followed by the absolute directories
5232
             that we search for startfiles.  */
5233
          case 'D':
5234
            {
5235
              struct spec_path_info info;
5236
 
5237
              info.option = "-L";
5238
              info.append_len = 0;
5239
#ifdef RELATIVE_PREFIX_NOT_LINKDIR
5240
              /* Used on systems which record the specified -L dirs
5241
                 and use them to search for dynamic linking.
5242
                 Relative directories always come from -B,
5243
                 and it is better not to use them for searching
5244
                 at run time.  In particular, stage1 loses.  */
5245
              info.omit_relative = true;
5246
#else
5247
              info.omit_relative = false;
5248
#endif
5249
              info.separate_options = false;
5250
 
5251
              for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5252
            }
5253
            break;
5254
 
5255
          case 'e':
5256
            /* %efoo means report an error with `foo' as error message
5257
               and don't execute any more commands for this file.  */
5258
            {
5259
              const char *q = p;
5260
              char *buf;
5261
              while (*p != 0 && *p != '\n')
5262
                p++;
5263
              buf = (char *) alloca (p - q + 1);
5264
              strncpy (buf, q, p - q);
5265
              buf[p - q] = 0;
5266
              error ("%s", _(buf));
5267
              return -1;
5268
            }
5269
            break;
5270
          case 'n':
5271
            /* %nfoo means report a notice with `foo' on stderr.  */
5272
            {
5273
              const char *q = p;
5274
              char *buf;
5275
              while (*p != 0 && *p != '\n')
5276
                p++;
5277
              buf = (char *) alloca (p - q + 1);
5278
              strncpy (buf, q, p - q);
5279
              buf[p - q] = 0;
5280
              notice ("%s\n", _(buf));
5281
              if (*p)
5282
                p++;
5283
            }
5284
            break;
5285
 
5286
          case 'j':
5287
            {
5288
              struct stat st;
5289
 
5290
              /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5291
                 defined, and it is not a directory, and it is
5292
                 writable, use it.  Otherwise, treat this like any
5293
                 other temporary file.  */
5294
 
5295
              if ((!save_temps_flag)
5296
                  && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5297
                  && (access (HOST_BIT_BUCKET, W_OK) == 0))
5298
                {
5299
                  obstack_grow (&obstack, HOST_BIT_BUCKET,
5300
                                strlen (HOST_BIT_BUCKET));
5301
                  delete_this_arg = 0;
5302
                  arg_going = 1;
5303
                  break;
5304
                }
5305
            }
5306
            goto create_temp_file;
5307
          case '|':
5308
            if (use_pipes)
5309
              {
5310
                obstack_1grow (&obstack, '-');
5311
                delete_this_arg = 0;
5312
                arg_going = 1;
5313
 
5314
                /* consume suffix */
5315
                while (*p == '.' || ISALNUM ((unsigned char) *p))
5316
                  p++;
5317
                if (p[0] == '%' && p[1] == 'O')
5318
                  p += 2;
5319
 
5320
                break;
5321
              }
5322
            goto create_temp_file;
5323
          case 'm':
5324
            if (use_pipes)
5325
              {
5326
                /* consume suffix */
5327
                while (*p == '.' || ISALNUM ((unsigned char) *p))
5328
                  p++;
5329
                if (p[0] == '%' && p[1] == 'O')
5330
                  p += 2;
5331
 
5332
                break;
5333
              }
5334
            goto create_temp_file;
5335
          case 'g':
5336
          case 'u':
5337
          case 'U':
5338
          create_temp_file:
5339
              {
5340
                struct temp_name *t;
5341
                int suffix_length;
5342
                const char *suffix = p;
5343
                char *saved_suffix = NULL;
5344
 
5345
                while (*p == '.' || ISALNUM ((unsigned char) *p))
5346
                  p++;
5347
                suffix_length = p - suffix;
5348
                if (p[0] == '%' && p[1] == 'O')
5349
                  {
5350
                    p += 2;
5351
                    /* We don't support extra suffix characters after %O.  */
5352
                    if (*p == '.' || ISALNUM ((unsigned char) *p))
5353
                      fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
5354
                    if (suffix_length == 0)
5355
                      suffix = TARGET_OBJECT_SUFFIX;
5356
                    else
5357
                      {
5358
                        saved_suffix
5359
                          = XNEWVEC (char, suffix_length
5360
                                     + strlen (TARGET_OBJECT_SUFFIX));
5361
                        strncpy (saved_suffix, suffix, suffix_length);
5362
                        strcpy (saved_suffix + suffix_length,
5363
                                TARGET_OBJECT_SUFFIX);
5364
                      }
5365
                    suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5366
                  }
5367
 
5368
                if (compare_debug < 0)
5369
                  {
5370
                    suffix = concat (".gk", suffix, NULL);
5371
                    suffix_length += 3;
5372
                  }
5373
 
5374
                /* If -save-temps=obj and -o were specified, use that for the
5375
                   temp file.  */
5376
                if (save_temps_length)
5377
                  {
5378
                    char *tmp;
5379
                    temp_filename_length
5380
                      = save_temps_length + suffix_length + 1;
5381
                    tmp = (char *) alloca (temp_filename_length);
5382
                    memcpy (tmp, save_temps_prefix, save_temps_length);
5383
                    memcpy (tmp + save_temps_length, suffix, suffix_length);
5384
                    tmp[save_temps_length + suffix_length] = '\0';
5385
                    temp_filename = save_string (tmp,
5386
                                                 temp_filename_length + 1);
5387
                    obstack_grow (&obstack, temp_filename,
5388
                                  temp_filename_length);
5389
                    arg_going = 1;
5390
                    delete_this_arg = 0;
5391
                    break;
5392
                  }
5393
 
5394
                /* If the input_filename has the same suffix specified
5395
                   for the %g, %u, or %U, and -save-temps is specified,
5396
                   we could end up using that file as an intermediate
5397
                   thus clobbering the user's source file (.e.g.,
5398
                   gcc -save-temps foo.s would clobber foo.s with the
5399
                   output of cpp0).  So check for this condition and
5400
                   generate a temp file as the intermediate.  */
5401
 
5402
                if (save_temps_flag)
5403
                  {
5404
                    char *tmp;
5405
                    temp_filename_length = basename_length + suffix_length + 1;
5406
                    tmp = (char *) alloca (temp_filename_length);
5407
                    memcpy (tmp, input_basename, basename_length);
5408
                    memcpy (tmp + basename_length, suffix, suffix_length);
5409
                    tmp[basename_length + suffix_length] = '\0';
5410
                    temp_filename = tmp;
5411
 
5412
                    if (strcmp (temp_filename, input_filename) != 0)
5413
                      {
5414
#ifndef HOST_LACKS_INODE_NUMBERS
5415
                        struct stat st_temp;
5416
 
5417
                        /* Note, set_input() resets input_stat_set to 0.  */
5418
                        if (input_stat_set == 0)
5419
                          {
5420
                            input_stat_set = stat (input_filename, &input_stat);
5421
                            if (input_stat_set >= 0)
5422
                              input_stat_set = 1;
5423
                          }
5424
 
5425
                        /* If we have the stat for the input_filename
5426
                           and we can do the stat for the temp_filename
5427
                           then the they could still refer to the same
5428
                           file if st_dev/st_ino's are the same.  */
5429
                        if (input_stat_set != 1
5430
                            || stat (temp_filename, &st_temp) < 0
5431
                            || input_stat.st_dev != st_temp.st_dev
5432
                            || input_stat.st_ino != st_temp.st_ino)
5433
#else
5434
                        /* Just compare canonical pathnames.  */
5435
                        char* input_realname = lrealpath (input_filename);
5436
                        char* temp_realname = lrealpath (temp_filename);
5437
                        bool files_differ = strcmp (input_realname, temp_realname);
5438
                        free (input_realname);
5439
                        free (temp_realname);
5440
                        if (files_differ)
5441
#endif
5442
                          {
5443
                            temp_filename = save_string (temp_filename,
5444
                                                         temp_filename_length + 1);
5445
                            obstack_grow (&obstack, temp_filename,
5446
                                                    temp_filename_length);
5447
                            arg_going = 1;
5448
                            delete_this_arg = 0;
5449
                            break;
5450
                          }
5451
                      }
5452
                  }
5453
 
5454
                /* See if we already have an association of %g/%u/%U and
5455
                   suffix.  */
5456
                for (t = temp_names; t; t = t->next)
5457
                  if (t->length == suffix_length
5458
                      && strncmp (t->suffix, suffix, suffix_length) == 0
5459
                      && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5460
                    break;
5461
 
5462
                /* Make a new association if needed.  %u and %j
5463
                   require one.  */
5464
                if (t == 0 || c == 'u' || c == 'j')
5465
                  {
5466
                    if (t == 0)
5467
                      {
5468
                        t = XNEW (struct temp_name);
5469
                        t->next = temp_names;
5470
                        temp_names = t;
5471
                      }
5472
                    t->length = suffix_length;
5473
                    if (saved_suffix)
5474
                      {
5475
                        t->suffix = saved_suffix;
5476
                        saved_suffix = NULL;
5477
                      }
5478
                    else
5479
                      t->suffix = save_string (suffix, suffix_length);
5480
                    t->unique = (c == 'u' || c == 'U' || c == 'j');
5481
                    temp_filename = make_temp_file (t->suffix);
5482
                    temp_filename_length = strlen (temp_filename);
5483
                    t->filename = temp_filename;
5484
                    t->filename_length = temp_filename_length;
5485
                  }
5486
 
5487
                if (saved_suffix)
5488
                  free (saved_suffix);
5489
 
5490
                obstack_grow (&obstack, t->filename, t->filename_length);
5491
                delete_this_arg = 1;
5492
              }
5493
            arg_going = 1;
5494
            break;
5495
 
5496
          case 'i':
5497
            if (combine_inputs)
5498
              {
5499
                if (at_file_supplied)
5500
                  {
5501
                    /* We are going to expand `%i' to `@FILE', where FILE
5502
                       is a newly-created temporary filename.  The filenames
5503
                       that would usually be expanded in place of %o will be
5504
                       written to the temporary file.  */
5505
                    char **argv;
5506
                    int n_files = 0;
5507
                    int j;
5508
 
5509
                    for (i = 0; i < n_infiles; i++)
5510
                      if (compile_input_file_p (&infiles[i]))
5511
                        n_files++;
5512
 
5513
                    argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5514
 
5515
                    /* Copy the strings over.  */
5516
                    for (i = 0, j = 0; i < n_infiles; i++)
5517
                      if (compile_input_file_p (&infiles[i]))
5518
                        {
5519
                          argv[j] = CONST_CAST (char *, infiles[i].name);
5520
                          infiles[i].compiled = true;
5521
                          j++;
5522
                        }
5523
                    argv[j] = NULL;
5524
 
5525
                    create_at_file (argv);
5526
                  }
5527
                else
5528
                  for (i = 0; (int) i < n_infiles; i++)
5529
                    if (compile_input_file_p (&infiles[i]))
5530
                      {
5531
                        store_arg (infiles[i].name, 0, 0);
5532
                        infiles[i].compiled = true;
5533
                      }
5534
              }
5535
            else
5536
              {
5537
                obstack_grow (&obstack, input_filename, input_filename_length);
5538
                arg_going = 1;
5539
              }
5540
            break;
5541
 
5542
          case 'I':
5543
            {
5544
              struct spec_path_info info;
5545
 
5546
              if (multilib_dir)
5547
                {
5548
                  do_spec_1 ("-imultilib", 1, NULL);
5549
                  /* Make this a separate argument.  */
5550
                  do_spec_1 (" ", 0, NULL);
5551
                  do_spec_1 (multilib_dir, 1, NULL);
5552
                  do_spec_1 (" ", 0, NULL);
5553
                }
5554
 
5555
              if (gcc_exec_prefix)
5556
                {
5557
                  do_spec_1 ("-iprefix", 1, NULL);
5558
                  /* Make this a separate argument.  */
5559
                  do_spec_1 (" ", 0, NULL);
5560
                  do_spec_1 (gcc_exec_prefix, 1, NULL);
5561
                  do_spec_1 (" ", 0, NULL);
5562
                }
5563
 
5564
              if (target_system_root_changed ||
5565
                  (target_system_root && target_sysroot_hdrs_suffix))
5566
                {
5567
                  do_spec_1 ("-isysroot", 1, NULL);
5568
                  /* Make this a separate argument.  */
5569
                  do_spec_1 (" ", 0, NULL);
5570
                  do_spec_1 (target_system_root, 1, NULL);
5571
                  if (target_sysroot_hdrs_suffix)
5572
                    do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5573
                  do_spec_1 (" ", 0, NULL);
5574
                }
5575
 
5576
              info.option = "-isystem";
5577
              info.append = "include";
5578
              info.append_len = strlen (info.append);
5579
              info.omit_relative = false;
5580
              info.separate_options = true;
5581
 
5582
              for_each_path (&include_prefixes, false, info.append_len,
5583
                             spec_path, &info);
5584
 
5585
              info.append = "include-fixed";
5586
              if (*sysroot_hdrs_suffix_spec)
5587
                info.append = concat (info.append, dir_separator_str,
5588
                                      multilib_dir, NULL);
5589
              info.append_len = strlen (info.append);
5590
              for_each_path (&include_prefixes, false, info.append_len,
5591
                             spec_path, &info);
5592
            }
5593
            break;
5594
 
5595
          case 'o':
5596
            {
5597
              int max = n_infiles;
5598
              max += lang_specific_extra_outfiles;
5599
 
5600
              if (HAVE_GNU_LD && at_file_supplied)
5601
                {
5602
                  /* We are going to expand `%o' to `@FILE', where FILE
5603
                     is a newly-created temporary filename.  The filenames
5604
                     that would usually be expanded in place of %o will be
5605
                     written to the temporary file.  */
5606
 
5607
                  char **argv;
5608
                  int n_files, j;
5609
 
5610
                  /* Convert OUTFILES into a form suitable for writeargv.  */
5611
 
5612
                  /* Determine how many are non-NULL.  */
5613
                  for (n_files = 0, i = 0; i < max; i++)
5614
                    n_files += outfiles[i] != NULL;
5615
 
5616
                  argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5617
 
5618
                  /* Copy the strings over.  */
5619
                  for (i = 0, j = 0; i < max; i++)
5620
                    if (outfiles[i])
5621
                      {
5622
                        argv[j] = CONST_CAST (char *, outfiles[i]);
5623
                        j++;
5624
                      }
5625
                  argv[j] = NULL;
5626
 
5627
                  create_at_file (argv);
5628
                }
5629
              else
5630
                for (i = 0; i < max; i++)
5631
                  if (outfiles[i])
5632
                    store_arg (outfiles[i], 0, 0);
5633
              break;
5634
            }
5635
 
5636
          case 'O':
5637
            obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5638
            arg_going = 1;
5639
            break;
5640
 
5641
          case 's':
5642
            this_is_library_file = 1;
5643
            break;
5644
 
5645
          case 'T':
5646
            this_is_linker_script = 1;
5647
            break;
5648
 
5649
          case 'V':
5650
            outfiles[input_file_number] = NULL;
5651
            break;
5652
 
5653
          case 'w':
5654
            this_is_output_file = 1;
5655
            break;
5656
 
5657
          case 'W':
5658
            {
5659
              int cur_index = argbuf_index;
5660
              /* Handle the {...} following the %W.  */
5661
              if (*p != '{')
5662
                fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5663
              p = handle_braces (p + 1);
5664
              if (p == 0)
5665
                return -1;
5666
              end_going_arg ();
5667
              /* If any args were output, mark the last one for deletion
5668
                 on failure.  */
5669
              if (argbuf_index != cur_index)
5670
                record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5671
              break;
5672
            }
5673
 
5674
          /* %x{OPTION} records OPTION for %X to output.  */
5675
          case 'x':
5676
            {
5677
              const char *p1 = p;
5678
              char *string;
5679
 
5680
              /* Skip past the option value and make a copy.  */
5681
              if (*p != '{')
5682
                fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5683
              while (*p++ != '}')
5684
                ;
5685
              string = save_string (p1 + 1, p - p1 - 2);
5686
 
5687
              /* See if we already recorded this option.  */
5688
              for (i = 0; i < n_linker_options; i++)
5689
                if (! strcmp (string, linker_options[i]))
5690
                  {
5691
                    free (string);
5692
                    return 0;
5693
                  }
5694
 
5695
              /* This option is new; add it.  */
5696
              add_linker_option (string, strlen (string));
5697
            }
5698
            break;
5699
 
5700
          /* Dump out the options accumulated previously using %x.  */
5701
          case 'X':
5702
            for (i = 0; i < n_linker_options; i++)
5703
              {
5704
                do_spec_1 (linker_options[i], 1, NULL);
5705
                /* Make each accumulated option a separate argument.  */
5706
                do_spec_1 (" ", 0, NULL);
5707
              }
5708
            break;
5709
 
5710
          /* Dump out the options accumulated previously using -Wa,.  */
5711
          case 'Y':
5712
            for (i = 0; i < n_assembler_options; i++)
5713
              {
5714
                do_spec_1 (assembler_options[i], 1, NULL);
5715
                /* Make each accumulated option a separate argument.  */
5716
                do_spec_1 (" ", 0, NULL);
5717
              }
5718
            break;
5719
 
5720
          /* Dump out the options accumulated previously using -Wp,.  */
5721
          case 'Z':
5722
            for (i = 0; i < n_preprocessor_options; i++)
5723
              {
5724
                do_spec_1 (preprocessor_options[i], 1, NULL);
5725
                /* Make each accumulated option a separate argument.  */
5726
                do_spec_1 (" ", 0, NULL);
5727
              }
5728
            break;
5729
 
5730
            /* Here are digits and numbers that just process
5731
               a certain constant string as a spec.  */
5732
 
5733
          case '1':
5734
            value = do_spec_1 (cc1_spec, 0, NULL);
5735
            if (value != 0)
5736
              return value;
5737
            break;
5738
 
5739
          case '2':
5740
            value = do_spec_1 (cc1plus_spec, 0, NULL);
5741
            if (value != 0)
5742
              return value;
5743
            break;
5744
 
5745
          case 'a':
5746
            value = do_spec_1 (asm_spec, 0, NULL);
5747
            if (value != 0)
5748
              return value;
5749
            break;
5750
 
5751
          case 'A':
5752
            value = do_spec_1 (asm_final_spec, 0, NULL);
5753
            if (value != 0)
5754
              return value;
5755
            break;
5756
 
5757
          case 'C':
5758
            {
5759
              const char *const spec
5760
                = (input_file_compiler->cpp_spec
5761
                   ? input_file_compiler->cpp_spec
5762
                   : cpp_spec);
5763
              value = do_spec_1 (spec, 0, NULL);
5764
              if (value != 0)
5765
                return value;
5766
            }
5767
            break;
5768
 
5769
          case 'E':
5770
            value = do_spec_1 (endfile_spec, 0, NULL);
5771
            if (value != 0)
5772
              return value;
5773
            break;
5774
 
5775
          case 'l':
5776
            value = do_spec_1 (link_spec, 0, NULL);
5777
            if (value != 0)
5778
              return value;
5779
            break;
5780
 
5781
          case 'L':
5782
            value = do_spec_1 (lib_spec, 0, NULL);
5783
            if (value != 0)
5784
              return value;
5785
            break;
5786
 
5787
          case 'G':
5788
            value = do_spec_1 (libgcc_spec, 0, NULL);
5789
            if (value != 0)
5790
              return value;
5791
            break;
5792
 
5793
          case 'R':
5794
            /* We assume there is a directory
5795
               separator at the end of this string.  */
5796
            if (target_system_root)
5797
              {
5798
                obstack_grow (&obstack, target_system_root,
5799
                              strlen (target_system_root));
5800
                if (target_sysroot_suffix)
5801
                  obstack_grow (&obstack, target_sysroot_suffix,
5802
                                strlen (target_sysroot_suffix));
5803
              }
5804
            break;
5805
 
5806
          case 'S':
5807
            value = do_spec_1 (startfile_spec, 0, NULL);
5808
            if (value != 0)
5809
              return value;
5810
            break;
5811
 
5812
            /* Here we define characters other than letters and digits.  */
5813
 
5814
          case '{':
5815
            p = handle_braces (p);
5816
            if (p == 0)
5817
              return -1;
5818
            break;
5819
 
5820
          case ':':
5821
            p = handle_spec_function (p);
5822
            if (p == 0)
5823
              return -1;
5824
            break;
5825
 
5826
          case '%':
5827
            obstack_1grow (&obstack, '%');
5828
            break;
5829
 
5830
          case '.':
5831
            {
5832
              unsigned len = 0;
5833
 
5834
              while (p[len] && p[len] != ' ' && p[len] != '%')
5835
                len++;
5836
              suffix_subst = save_string (p - 1, len + 1);
5837
              p += len;
5838
            }
5839
           break;
5840
 
5841
           /* Henceforth ignore the option(s) matching the pattern
5842
              after the %<.  */
5843
          case '<':
5844
            {
5845
              unsigned len = 0;
5846
              int have_wildcard = 0;
5847
              int i;
5848
 
5849
              while (p[len] && p[len] != ' ' && p[len] != '\t')
5850
                len++;
5851
 
5852
              if (p[len-1] == '*')
5853
                have_wildcard = 1;
5854
 
5855
              for (i = 0; i < n_switches; i++)
5856
                if (!strncmp (switches[i].part1, p, len - have_wildcard)
5857
                    && (have_wildcard || switches[i].part1[len] == '\0'))
5858
                  {
5859
                    switches[i].live_cond |= SWITCH_IGNORE;
5860
                    switches[i].validated = 1;
5861
                  }
5862
 
5863
              p += len;
5864
            }
5865
            break;
5866
 
5867
          case '*':
5868
            if (soft_matched_part)
5869
              {
5870
                do_spec_1 (soft_matched_part, 1, NULL);
5871
                do_spec_1 (" ", 0, NULL);
5872
              }
5873
            else
5874
              /* Catch the case where a spec string contains something like
5875
                 '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5876
                 hand side of the :.  */
5877
              error ("spec failure: '%%*' has not been initialized by pattern match");
5878
            break;
5879
 
5880
            /* Process a string found as the value of a spec given by name.
5881
               This feature allows individual machine descriptions
5882
               to add and use their own specs.
5883
               %[...] modifies -D options the way %P does;
5884
               %(...) uses the spec unmodified.  */
5885
          case '[':
5886
            error ("warning: use of obsolete %%[ operator in specs");
5887
          case '(':
5888
            {
5889
              const char *name = p;
5890
              struct spec_list *sl;
5891
              int len;
5892
 
5893
              /* The string after the S/P is the name of a spec that is to be
5894
                 processed.  */
5895
              while (*p && *p != ')' && *p != ']')
5896
                p++;
5897
 
5898
              /* See if it's in the list.  */
5899
              for (len = p - name, sl = specs; sl; sl = sl->next)
5900
                if (sl->name_len == len && !strncmp (sl->name, name, len))
5901
                  {
5902
                    name = *(sl->ptr_spec);
5903
#ifdef DEBUG_SPECS
5904
                    notice ("Processing spec %c%s%c, which is '%s'\n",
5905
                            c, sl->name, (c == '(') ? ')' : ']', name);
5906
#endif
5907
                    break;
5908
                  }
5909
 
5910
              if (sl)
5911
                {
5912
                  if (c == '(')
5913
                    {
5914
                      value = do_spec_1 (name, 0, NULL);
5915
                      if (value != 0)
5916
                        return value;
5917
                    }
5918
                  else
5919
                    {
5920
                      char *x = (char *) alloca (strlen (name) * 2 + 1);
5921
                      char *buf = x;
5922
                      const char *y = name;
5923
                      int flag = 0;
5924
 
5925
                      /* Copy all of NAME into BUF, but put __ after
5926
                         every -D and at the end of each arg.  */
5927
                      while (1)
5928
                        {
5929
                          if (! strncmp (y, "-D", 2))
5930
                            {
5931
                              *x++ = '-';
5932
                              *x++ = 'D';
5933
                              *x++ = '_';
5934
                              *x++ = '_';
5935
                              y += 2;
5936
                              flag = 1;
5937
                              continue;
5938
                            }
5939
                          else if (flag
5940
                                   && (*y == ' ' || *y == '\t' || *y == '='
5941
                                       || *y == '}' || *y == 0))
5942
                            {
5943
                              *x++ = '_';
5944
                              *x++ = '_';
5945
                              flag = 0;
5946
                            }
5947
                          if (*y == 0)
5948
                            break;
5949
                          else
5950
                            *x++ = *y++;
5951
                        }
5952
                      *x = 0;
5953
 
5954
                      value = do_spec_1 (buf, 0, NULL);
5955
                      if (value != 0)
5956
                        return value;
5957
                    }
5958
                }
5959
 
5960
              /* Discard the closing paren or bracket.  */
5961
              if (*p)
5962
                p++;
5963
            }
5964
            break;
5965
 
5966
          default:
5967
            error ("spec failure: unrecognized spec option '%c'", c);
5968
            break;
5969
          }
5970
        break;
5971
 
5972
      case '\\':
5973
        /* Backslash: treat next character as ordinary.  */
5974
        c = *p++;
5975
 
5976
        /* Fall through.  */
5977
      default:
5978
        /* Ordinary character: put it into the current argument.  */
5979
        obstack_1grow (&obstack, c);
5980
        arg_going = 1;
5981
      }
5982
 
5983
  /* End of string.  If we are processing a spec function, we need to
5984
     end any pending argument.  */
5985
  if (processing_spec_function)
5986
    end_going_arg ();
5987
 
5988
  return 0;
5989
}
5990
 
5991
/* Look up a spec function.  */
5992
 
5993
static const struct spec_function *
5994
lookup_spec_function (const char *name)
5995
{
5996
  const struct spec_function *sf;
5997
 
5998
  for (sf = static_spec_functions; sf->name != NULL; sf++)
5999
    if (strcmp (sf->name, name) == 0)
6000
      return sf;
6001
 
6002
  return NULL;
6003
}
6004
 
6005
/* Evaluate a spec function.  */
6006
 
6007
static const char *
6008
eval_spec_function (const char *func, const char *args)
6009
{
6010
  const struct spec_function *sf;
6011
  const char *funcval;
6012
 
6013
  /* Saved spec processing context.  */
6014
  int save_argbuf_index;
6015
  int save_argbuf_length;
6016
  const char **save_argbuf;
6017
 
6018
  int save_arg_going;
6019
  int save_delete_this_arg;
6020
  int save_this_is_output_file;
6021
  int save_this_is_library_file;
6022
  int save_input_from_pipe;
6023
  int save_this_is_linker_script;
6024
  const char *save_suffix_subst;
6025
 
6026
 
6027
  sf = lookup_spec_function (func);
6028
  if (sf == NULL)
6029
    fatal ("unknown spec function '%s'", func);
6030
 
6031
  /* Push the spec processing context.  */
6032
  save_argbuf_index = argbuf_index;
6033
  save_argbuf_length = argbuf_length;
6034
  save_argbuf = argbuf;
6035
 
6036
  save_arg_going = arg_going;
6037
  save_delete_this_arg = delete_this_arg;
6038
  save_this_is_output_file = this_is_output_file;
6039
  save_this_is_library_file = this_is_library_file;
6040
  save_this_is_linker_script = this_is_linker_script;
6041
  save_input_from_pipe = input_from_pipe;
6042
  save_suffix_subst = suffix_subst;
6043
 
6044
  /* Create a new spec processing context, and build the function
6045
     arguments.  */
6046
 
6047
  alloc_args ();
6048
  if (do_spec_2 (args) < 0)
6049
    fatal ("error in args to spec function '%s'", func);
6050
 
6051
  /* argbuf_index is an index for the next argument to be inserted, and
6052
     so contains the count of the args already inserted.  */
6053
 
6054
  funcval = (*sf->func) (argbuf_index, argbuf);
6055
 
6056
  /* Pop the spec processing context.  */
6057
  argbuf_index = save_argbuf_index;
6058
  argbuf_length = save_argbuf_length;
6059
  free (argbuf);
6060
  argbuf = save_argbuf;
6061
 
6062
  arg_going = save_arg_going;
6063
  delete_this_arg = save_delete_this_arg;
6064
  this_is_output_file = save_this_is_output_file;
6065
  this_is_library_file = save_this_is_library_file;
6066
  this_is_linker_script = save_this_is_linker_script;
6067
  input_from_pipe = save_input_from_pipe;
6068
  suffix_subst = save_suffix_subst;
6069
 
6070
  return funcval;
6071
}
6072
 
6073
/* Handle a spec function call of the form:
6074
 
6075
   %:function(args)
6076
 
6077
   ARGS is processed as a spec in a separate context and split into an
6078
   argument vector in the normal fashion.  The function returns a string
6079
   containing a spec which we then process in the caller's context, or
6080
   NULL if no processing is required.  */
6081
 
6082
static const char *
6083
handle_spec_function (const char *p)
6084
{
6085
  char *func, *args;
6086
  const char *endp, *funcval;
6087
  int count;
6088
 
6089
  processing_spec_function++;
6090
 
6091
  /* Get the function name.  */
6092
  for (endp = p; *endp != '\0'; endp++)
6093
    {
6094
      if (*endp == '(')         /* ) */
6095
        break;
6096
      /* Only allow [A-Za-z0-9], -, and _ in function names.  */
6097
      if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6098
        fatal ("malformed spec function name");
6099
    }
6100
  if (*endp != '(')             /* ) */
6101
    fatal ("no arguments for spec function");
6102
  func = save_string (p, endp - p);
6103
  p = ++endp;
6104
 
6105
  /* Get the arguments.  */
6106
  for (count = 0; *endp != '\0'; endp++)
6107
    {
6108
      /* ( */
6109
      if (*endp == ')')
6110
        {
6111
          if (count == 0)
6112
            break;
6113
          count--;
6114
        }
6115
      else if (*endp == '(')    /* ) */
6116
        count++;
6117
    }
6118
  /* ( */
6119
  if (*endp != ')')
6120
    fatal ("malformed spec function arguments");
6121
  args = save_string (p, endp - p);
6122
  p = ++endp;
6123
 
6124
  /* p now points to just past the end of the spec function expression.  */
6125
 
6126
  funcval = eval_spec_function (func, args);
6127
  if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6128
    p = NULL;
6129
 
6130
  free (func);
6131
  free (args);
6132
 
6133
  processing_spec_function--;
6134
 
6135
  return p;
6136
}
6137
 
6138
/* Inline subroutine of handle_braces.  Returns true if the current
6139
   input suffix matches the atom bracketed by ATOM and END_ATOM.  */
6140
static inline bool
6141
input_suffix_matches (const char *atom, const char *end_atom)
6142
{
6143
  return (input_suffix
6144
          && !strncmp (input_suffix, atom, end_atom - atom)
6145
          && input_suffix[end_atom - atom] == '\0');
6146
}
6147
 
6148
/* Subroutine of handle_braces.  Returns true if the current
6149
   input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
6150
static bool
6151
input_spec_matches (const char *atom, const char *end_atom)
6152
{
6153
  return (input_file_compiler
6154
          && input_file_compiler->suffix
6155
          && input_file_compiler->suffix[0] != '\0'
6156
          && !strncmp (input_file_compiler->suffix + 1, atom,
6157
                       end_atom - atom)
6158
          && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6159
}
6160
 
6161
/* Subroutine of handle_braces.  Returns true if a switch
6162
   matching the atom bracketed by ATOM and END_ATOM appeared on the
6163
   command line.  */
6164
static bool
6165
switch_matches (const char *atom, const char *end_atom, int starred)
6166
{
6167
  int i;
6168
  int len = end_atom - atom;
6169
  int plen = starred ? len : -1;
6170
 
6171
  for (i = 0; i < n_switches; i++)
6172
    if (!strncmp (switches[i].part1, atom, len)
6173
        && (starred || switches[i].part1[len] == '\0')
6174
        && check_live_switch (i, plen))
6175
      return true;
6176
 
6177
  return false;
6178
}
6179
 
6180
/* Inline subroutine of handle_braces.  Mark all of the switches which
6181
   match ATOM (extends to END_ATOM; STARRED indicates whether there
6182
   was a star after the atom) for later processing.  */
6183
static inline void
6184
mark_matching_switches (const char *atom, const char *end_atom, int starred)
6185
{
6186
  int i;
6187
  int len = end_atom - atom;
6188
  int plen = starred ? len : -1;
6189
 
6190
  for (i = 0; i < n_switches; i++)
6191
    if (!strncmp (switches[i].part1, atom, len)
6192
        && (starred || switches[i].part1[len] == '\0')
6193
        && check_live_switch (i, plen))
6194
      switches[i].ordering = 1;
6195
}
6196
 
6197
/* Inline subroutine of handle_braces.  Process all the currently
6198
   marked switches through give_switch, and clear the marks.  */
6199
static inline void
6200
process_marked_switches (void)
6201
{
6202
  int i;
6203
 
6204
  for (i = 0; i < n_switches; i++)
6205
    if (switches[i].ordering == 1)
6206
      {
6207
        switches[i].ordering = 0;
6208
        give_switch (i, 0);
6209
      }
6210
}
6211
 
6212
/* Handle a %{ ... } construct.  P points just inside the leading {.
6213
   Returns a pointer one past the end of the brace block, or 0
6214
   if we call do_spec_1 and that returns -1.  */
6215
 
6216
static const char *
6217
handle_braces (const char *p)
6218
{
6219
  const char *atom, *end_atom;
6220
  const char *d_atom = NULL, *d_end_atom = NULL;
6221
  const char *orig = p;
6222
 
6223
  bool a_is_suffix;
6224
  bool a_is_spectype;
6225
  bool a_is_starred;
6226
  bool a_is_negated;
6227
  bool a_matched;
6228
 
6229
  bool a_must_be_last = false;
6230
  bool ordered_set    = false;
6231
  bool disjunct_set   = false;
6232
  bool disj_matched   = false;
6233
  bool disj_starred   = true;
6234
  bool n_way_choice   = false;
6235
  bool n_way_matched  = false;
6236
 
6237
#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6238
 
6239
  do
6240
    {
6241
      if (a_must_be_last)
6242
        goto invalid;
6243
 
6244
      /* Scan one "atom" (S in the description above of %{}, possibly
6245
         with '!', '.', '@', ',', or '*' modifiers).  */
6246
      a_matched = false;
6247
      a_is_suffix = false;
6248
      a_is_starred = false;
6249
      a_is_negated = false;
6250
      a_is_spectype = false;
6251
 
6252
      SKIP_WHITE();
6253
      if (*p == '!')
6254
        p++, a_is_negated = true;
6255
 
6256
      SKIP_WHITE();
6257
      if (*p == '.')
6258
        p++, a_is_suffix = true;
6259
      else if (*p == ',')
6260
        p++, a_is_spectype = true;
6261
 
6262
      atom = p;
6263
      while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6264
             || *p == ',' || *p == '.' || *p == '@')
6265
        p++;
6266
      end_atom = p;
6267
 
6268
      if (*p == '*')
6269
        p++, a_is_starred = 1;
6270
 
6271
      SKIP_WHITE();
6272
      switch (*p)
6273
        {
6274
        case '&': case '}':
6275
          /* Substitute the switch(es) indicated by the current atom.  */
6276
          ordered_set = true;
6277
          if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6278
              || a_is_spectype || atom == end_atom)
6279
            goto invalid;
6280
 
6281
          mark_matching_switches (atom, end_atom, a_is_starred);
6282
 
6283
          if (*p == '}')
6284
            process_marked_switches ();
6285
          break;
6286
 
6287
        case '|': case ':':
6288
          /* Substitute some text if the current atom appears as a switch
6289
             or suffix.  */
6290
          disjunct_set = true;
6291
          if (ordered_set)
6292
            goto invalid;
6293
 
6294
          if (atom == end_atom)
6295
            {
6296
              if (!n_way_choice || disj_matched || *p == '|'
6297
                  || a_is_negated || a_is_suffix || a_is_spectype
6298
                  || a_is_starred)
6299
                goto invalid;
6300
 
6301
              /* An empty term may appear as the last choice of an
6302
                 N-way choice set; it means "otherwise".  */
6303
              a_must_be_last = true;
6304
              disj_matched = !n_way_matched;
6305
              disj_starred = false;
6306
            }
6307
          else
6308
            {
6309
              if ((a_is_suffix || a_is_spectype) && a_is_starred)
6310
                goto invalid;
6311
 
6312
              if (!a_is_starred)
6313
                disj_starred = false;
6314
 
6315
              /* Don't bother testing this atom if we already have a
6316
                 match.  */
6317
              if (!disj_matched && !n_way_matched)
6318
                {
6319
                  if (a_is_suffix)
6320
                    a_matched = input_suffix_matches (atom, end_atom);
6321
                  else if (a_is_spectype)
6322
                    a_matched = input_spec_matches (atom, end_atom);
6323
                  else
6324
                    a_matched = switch_matches (atom, end_atom, a_is_starred);
6325
 
6326
                  if (a_matched != a_is_negated)
6327
                    {
6328
                      disj_matched = true;
6329
                      d_atom = atom;
6330
                      d_end_atom = end_atom;
6331
                    }
6332
                }
6333
            }
6334
 
6335
          if (*p == ':')
6336
            {
6337
              /* Found the body, that is, the text to substitute if the
6338
                 current disjunction matches.  */
6339
              p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6340
                                      disj_matched && !n_way_matched);
6341
              if (p == 0)
6342
                return 0;
6343
 
6344
              /* If we have an N-way choice, reset state for the next
6345
                 disjunction.  */
6346
              if (*p == ';')
6347
                {
6348
                  n_way_choice = true;
6349
                  n_way_matched |= disj_matched;
6350
                  disj_matched = false;
6351
                  disj_starred = true;
6352
                  d_atom = d_end_atom = NULL;
6353
                }
6354
            }
6355
          break;
6356
 
6357
        default:
6358
          goto invalid;
6359
        }
6360
    }
6361
  while (*p++ != '}');
6362
 
6363
  return p;
6364
 
6365
 invalid:
6366
  fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
6367
 
6368
#undef SKIP_WHITE
6369
}
6370
 
6371
/* Subroutine of handle_braces.  Scan and process a brace substitution body
6372
   (X in the description of %{} syntax).  P points one past the colon;
6373
   ATOM and END_ATOM bracket the first atom which was found to be true
6374
   (present) in the current disjunction; STARRED indicates whether all
6375
   the atoms in the current disjunction were starred (for syntax validation);
6376
   MATCHED indicates whether the disjunction matched or not, and therefore
6377
   whether or not the body is to be processed through do_spec_1 or just
6378
   skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
6379
   returns -1.  */
6380
 
6381
static const char *
6382
process_brace_body (const char *p, const char *atom, const char *end_atom,
6383
                    int starred, int matched)
6384
{
6385
  const char *body, *end_body;
6386
  unsigned int nesting_level;
6387
  bool have_subst     = false;
6388
 
6389
  /* Locate the closing } or ;, honoring nested braces.
6390
     Trim trailing whitespace.  */
6391
  body = p;
6392
  nesting_level = 1;
6393
  for (;;)
6394
    {
6395
      if (*p == '{')
6396
        nesting_level++;
6397
      else if (*p == '}')
6398
        {
6399
          if (!--nesting_level)
6400
            break;
6401
        }
6402
      else if (*p == ';' && nesting_level == 1)
6403
        break;
6404
      else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6405
        have_subst = true;
6406
      else if (*p == '\0')
6407
        goto invalid;
6408
      p++;
6409
    }
6410
 
6411
  end_body = p;
6412
  while (end_body[-1] == ' ' || end_body[-1] == '\t')
6413
    end_body--;
6414
 
6415
  if (have_subst && !starred)
6416
    goto invalid;
6417
 
6418
  if (matched)
6419
    {
6420
      /* Copy the substitution body to permanent storage and execute it.
6421
         If have_subst is false, this is a simple matter of running the
6422
         body through do_spec_1...  */
6423
      char *string = save_string (body, end_body - body);
6424
      if (!have_subst)
6425
        {
6426
          if (do_spec_1 (string, 0, NULL) < 0)
6427
            return 0;
6428
        }
6429
      else
6430
        {
6431
          /* ... but if have_subst is true, we have to process the
6432
             body once for each matching switch, with %* set to the
6433
             variant part of the switch.  */
6434
          unsigned int hard_match_len = end_atom - atom;
6435
          int i;
6436
 
6437
          for (i = 0; i < n_switches; i++)
6438
            if (!strncmp (switches[i].part1, atom, hard_match_len)
6439
                && check_live_switch (i, hard_match_len))
6440
              {
6441
                if (do_spec_1 (string, 0,
6442
                               &switches[i].part1[hard_match_len]) < 0)
6443
                  return 0;
6444
                /* Pass any arguments this switch has.  */
6445
                give_switch (i, 1);
6446
                suffix_subst = NULL;
6447
              }
6448
        }
6449
    }
6450
 
6451
  return p;
6452
 
6453
 invalid:
6454
  fatal ("braced spec body '%s' is invalid", body);
6455
}
6456
 
6457
/* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6458
   on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
6459
   spec, or -1 if either exact match or %* is used.
6460
 
6461
   A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
6462
   whose value does not begin with "no-" is obsoleted by the same value
6463
   with the "no-", similarly for a switch with the "no-" prefix.  */
6464
 
6465
static int
6466
check_live_switch (int switchnum, int prefix_length)
6467
{
6468
  const char *name = switches[switchnum].part1;
6469
  int i;
6470
 
6471
  /* If we already processed this switch and determined if it was
6472
     live or not, return our past determination.  */
6473
  if (switches[switchnum].live_cond != 0)
6474
    return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6475
            && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6476
            && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6477
               == 0);
6478
 
6479
  /* In the common case of {<at-most-one-letter>*}, a negating
6480
     switch would always match, so ignore that case.  We will just
6481
     send the conflicting switches to the compiler phase.  */
6482
  if (prefix_length >= 0 && prefix_length <= 1)
6483
    return 1;
6484
 
6485
  /* Now search for duplicate in a manner that depends on the name.  */
6486
  switch (*name)
6487
    {
6488
    case 'O':
6489
      for (i = switchnum + 1; i < n_switches; i++)
6490
        if (switches[i].part1[0] == 'O')
6491
          {
6492
            switches[switchnum].validated = 1;
6493
            switches[switchnum].live_cond = SWITCH_FALSE;
6494
            return 0;
6495
          }
6496
      break;
6497
 
6498
    case 'W':  case 'f':  case 'm':
6499
      if (! strncmp (name + 1, "no-", 3))
6500
        {
6501
          /* We have Xno-YYY, search for XYYY.  */
6502
          for (i = switchnum + 1; i < n_switches; i++)
6503
            if (switches[i].part1[0] == name[0]
6504
                && ! strcmp (&switches[i].part1[1], &name[4]))
6505
              {
6506
                switches[switchnum].validated = 1;
6507
                switches[switchnum].live_cond = SWITCH_FALSE;
6508
                return 0;
6509
              }
6510
        }
6511
      else
6512
        {
6513
          /* We have XYYY, search for Xno-YYY.  */
6514
          for (i = switchnum + 1; i < n_switches; i++)
6515
            if (switches[i].part1[0] == name[0]
6516
                && switches[i].part1[1] == 'n'
6517
                && switches[i].part1[2] == 'o'
6518
                && switches[i].part1[3] == '-'
6519
                && !strcmp (&switches[i].part1[4], &name[1]))
6520
              {
6521
                switches[switchnum].validated = 1;
6522
                switches[switchnum].live_cond = SWITCH_FALSE;
6523
                return 0;
6524
              }
6525
        }
6526
      break;
6527
    }
6528
 
6529
  /* Otherwise the switch is live.  */
6530
  switches[switchnum].live_cond |= SWITCH_LIVE;
6531
  return 1;
6532
}
6533
 
6534
/* Pass a switch to the current accumulating command
6535
   in the same form that we received it.
6536
   SWITCHNUM identifies the switch; it is an index into
6537
   the vector of switches gcc received, which is `switches'.
6538
   This cannot fail since it never finishes a command line.
6539
 
6540
   If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
6541
 
6542
static void
6543
give_switch (int switchnum, int omit_first_word)
6544
{
6545
  if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6546
    return;
6547
 
6548
  if (!omit_first_word)
6549
    {
6550
      do_spec_1 ("-", 0, NULL);
6551
      do_spec_1 (switches[switchnum].part1, 1, NULL);
6552
    }
6553
 
6554
  if (switches[switchnum].args != 0)
6555
    {
6556
      const char **p;
6557
      for (p = switches[switchnum].args; *p; p++)
6558
        {
6559
          const char *arg = *p;
6560
 
6561
          do_spec_1 (" ", 0, NULL);
6562
          if (suffix_subst)
6563
            {
6564
              unsigned length = strlen (arg);
6565
              int dot = 0;
6566
 
6567
              while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6568
                if (arg[length] == '.')
6569
                  {
6570
                    (CONST_CAST(char *, arg))[length] = 0;
6571
                    dot = 1;
6572
                    break;
6573
                  }
6574
              do_spec_1 (arg, 1, NULL);
6575
              if (dot)
6576
                (CONST_CAST(char *, arg))[length] = '.';
6577
              do_spec_1 (suffix_subst, 1, NULL);
6578
            }
6579
          else
6580
            do_spec_1 (arg, 1, NULL);
6581
        }
6582
    }
6583
 
6584
  do_spec_1 (" ", 0, NULL);
6585
  switches[switchnum].validated = 1;
6586
}
6587
 
6588
/* Search for a file named NAME trying various prefixes including the
6589
   user's -B prefix and some standard ones.
6590
   Return the absolute file name found.  If nothing is found, return NAME.  */
6591
 
6592
static const char *
6593
find_file (const char *name)
6594
{
6595
  char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6596
  return newname ? newname : name;
6597
}
6598
 
6599
/* Determine whether a directory exists.  If LINKER, return 0 for
6600
   certain fixed names not needed by the linker.  */
6601
 
6602
static int
6603
is_directory (const char *path1, bool linker)
6604
{
6605
  int len1;
6606
  char *path;
6607
  char *cp;
6608
  struct stat st;
6609
 
6610
  /* Ensure the string ends with "/.".  The resulting path will be a
6611
     directory even if the given path is a symbolic link.  */
6612
  len1 = strlen (path1);
6613
  path = (char *) alloca (3 + len1);
6614
  memcpy (path, path1, len1);
6615
  cp = path + len1;
6616
  if (!IS_DIR_SEPARATOR (cp[-1]))
6617
    *cp++ = DIR_SEPARATOR;
6618
  *cp++ = '.';
6619
  *cp = '\0';
6620
 
6621
  /* Exclude directories that the linker is known to search.  */
6622
  if (linker
6623
      && IS_DIR_SEPARATOR (path[0])
6624
      && ((cp - path == 6
6625
           && strncmp (path + 1, "lib", 3) == 0)
6626
          || (cp - path == 10
6627
              && strncmp (path + 1, "usr", 3) == 0
6628
              && IS_DIR_SEPARATOR (path[4])
6629
              && strncmp (path + 5, "lib", 3) == 0)))
6630
    return 0;
6631
 
6632
  return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6633
}
6634
 
6635
/* Set up the various global variables to indicate that we're processing
6636
   the input file named FILENAME.  */
6637
 
6638
void
6639
set_input (const char *filename)
6640
{
6641
  const char *p;
6642
 
6643
  input_filename = filename;
6644
  input_filename_length = strlen (input_filename);
6645
  input_basename = lbasename (input_filename);
6646
 
6647
  /* Find a suffix starting with the last period,
6648
     and set basename_length to exclude that suffix.  */
6649
  basename_length = strlen (input_basename);
6650
  suffixed_basename_length = basename_length;
6651
  p = input_basename + basename_length;
6652
  while (p != input_basename && *p != '.')
6653
    --p;
6654
  if (*p == '.' && p != input_basename)
6655
    {
6656
      basename_length = p - input_basename;
6657
      input_suffix = p + 1;
6658
    }
6659
  else
6660
    input_suffix = "";
6661
 
6662
  /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6663
     we will need to do a stat on the input_filename.  The
6664
     INPUT_STAT_SET signals that the stat is needed.  */
6665
  input_stat_set = 0;
6666
}
6667
 
6668
/* On fatal signals, delete all the temporary files.  */
6669
 
6670
static void
6671
fatal_error (int signum)
6672
{
6673
  signal (signum, SIG_DFL);
6674
  delete_failure_queue ();
6675
  delete_temp_files ();
6676
  /* Get the same signal again, this time not handled,
6677
     so its normal effect occurs.  */
6678
  kill (getpid (), signum);
6679
}
6680
 
6681
/* Compare the contents of the two files named CMPFILE[0] and
6682
   CMPFILE[1].  Return zero if they're identical, nonzero
6683
   otherwise.  */
6684
 
6685
static int
6686
compare_files (char *cmpfile[])
6687
{
6688
  int ret = 0;
6689
  FILE *temp[2] = { NULL, NULL };
6690
  int i;
6691
 
6692
#if HAVE_MMAP_FILE
6693
  {
6694
    size_t length[2];
6695
    void *map[2] = { NULL, NULL };
6696
 
6697
    for (i = 0; i < 2; i++)
6698
      {
6699
        struct stat st;
6700
 
6701
        if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6702
          {
6703
            error ("%s: could not determine length of compare-debug file %s",
6704
                   input_filename, cmpfile[i]);
6705
            ret = 1;
6706
            break;
6707
          }
6708
 
6709
        length[i] = st.st_size;
6710
      }
6711
 
6712
    if (!ret && length[0] != length[1])
6713
      {
6714
        error ("%s: -fcompare-debug failure (length)", input_filename);
6715
        ret = 1;
6716
      }
6717
 
6718
    if (!ret)
6719
      for (i = 0; i < 2; i++)
6720
        {
6721
          int fd = open (cmpfile[i], O_RDONLY);
6722
          if (fd < 0)
6723
            {
6724
              error ("%s: could not open compare-debug file %s",
6725
                     input_filename, cmpfile[i]);
6726
              ret = 1;
6727
              break;
6728
            }
6729
 
6730
          map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6731
          close (fd);
6732
 
6733
          if (map[i] == (void *) MAP_FAILED)
6734
            {
6735
              ret = -1;
6736
              break;
6737
            }
6738
        }
6739
 
6740
    if (!ret)
6741
      {
6742
        if (memcmp (map[0], map[1], length[0]) != 0)
6743
          {
6744
            error ("%s: -fcompare-debug failure", input_filename);
6745
            ret = 1;
6746
          }
6747
      }
6748
 
6749
    for (i = 0; i < 2; i++)
6750
      if (map[i])
6751
        munmap ((caddr_t) map[i], length[i]);
6752
 
6753
    if (ret >= 0)
6754
      return ret;
6755
 
6756
    ret = 0;
6757
  }
6758
#endif
6759
 
6760
  for (i = 0; i < 2; i++)
6761
    {
6762
      temp[i] = fopen (cmpfile[i], "r");
6763
      if (!temp[i])
6764
        {
6765
          error ("%s: could not open compare-debug file %s",
6766
                 input_filename, cmpfile[i]);
6767
          ret = 1;
6768
          break;
6769
        }
6770
    }
6771
 
6772
  if (!ret && temp[0] && temp[1])
6773
    for (;;)
6774
      {
6775
        int c0, c1;
6776
        c0 = fgetc (temp[0]);
6777
        c1 = fgetc (temp[1]);
6778
 
6779
        if (c0 != c1)
6780
          {
6781
            error ("%s: -fcompare-debug failure",
6782
                   input_filename);
6783
            ret = 1;
6784
            break;
6785
          }
6786
 
6787
        if (c0 == EOF)
6788
          break;
6789
      }
6790
 
6791
  for (i = 1; i >= 0; i--)
6792
    {
6793
      if (temp[i])
6794
        fclose (temp[i]);
6795
    }
6796
 
6797
  return ret;
6798
}
6799
 
6800
extern int main (int, char **);
6801
 
6802
int
6803
main (int argc, char **argv)
6804
{
6805
  size_t i;
6806
  int value;
6807
  int linker_was_run = 0;
6808
  int lang_n_infiles = 0;
6809
  int num_linker_inputs = 0;
6810
  char *explicit_link_files;
6811
  char *specs_file;
6812
  const char *p;
6813
  struct user_specs *uptr;
6814
  char **old_argv = argv;
6815
 
6816
  /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
6817
     on ?: in file-scope variable initializations.  */
6818
  asm_debug = ASM_DEBUG_SPEC;
6819
 
6820
  p = argv[0] + strlen (argv[0]);
6821
  while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6822
    --p;
6823
  programname = p;
6824
 
6825
  xmalloc_set_program_name (programname);
6826
 
6827
  expandargv (&argc, &argv);
6828
 
6829
  /* Determine if any expansions were made.  */
6830
  if (argv != old_argv)
6831
    at_file_supplied = true;
6832
 
6833
  prune_options (&argc, &argv);
6834
 
6835
#ifdef GCC_DRIVER_HOST_INITIALIZATION
6836
  /* Perform host dependent initialization when needed.  */
6837
  GCC_DRIVER_HOST_INITIALIZATION;
6838
#endif
6839
 
6840
  /* Unlock the stdio streams.  */
6841
  unlock_std_streams ();
6842
 
6843
  gcc_init_libintl ();
6844
 
6845
  if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6846
    signal (SIGINT, fatal_error);
6847
#ifdef SIGHUP
6848
  if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6849
    signal (SIGHUP, fatal_error);
6850
#endif
6851
  if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6852
    signal (SIGTERM, fatal_error);
6853
#ifdef SIGPIPE
6854
  if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6855
    signal (SIGPIPE, fatal_error);
6856
#endif
6857
#ifdef SIGCHLD
6858
  /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6859
     receive the signal.  A different setting is inheritable */
6860
  signal (SIGCHLD, SIG_DFL);
6861
#endif
6862
 
6863
  /* Allocate the argument vector.  */
6864
  alloc_args ();
6865
 
6866
  obstack_init (&obstack);
6867
 
6868
  /* Build multilib_select, et. al from the separate lines that make up each
6869
     multilib selection.  */
6870
  {
6871
    const char *const *q = multilib_raw;
6872
    int need_space;
6873
 
6874
    obstack_init (&multilib_obstack);
6875
    while ((p = *q++) != (char *) 0)
6876
      obstack_grow (&multilib_obstack, p, strlen (p));
6877
 
6878
    obstack_1grow (&multilib_obstack, 0);
6879
    multilib_select = XOBFINISH (&multilib_obstack, const char *);
6880
 
6881
    q = multilib_matches_raw;
6882
    while ((p = *q++) != (char *) 0)
6883
      obstack_grow (&multilib_obstack, p, strlen (p));
6884
 
6885
    obstack_1grow (&multilib_obstack, 0);
6886
    multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6887
 
6888
    q = multilib_exclusions_raw;
6889
    while ((p = *q++) != (char *) 0)
6890
      obstack_grow (&multilib_obstack, p, strlen (p));
6891
 
6892
    obstack_1grow (&multilib_obstack, 0);
6893
    multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6894
 
6895
    need_space = FALSE;
6896
    for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6897
      {
6898
        if (need_space)
6899
          obstack_1grow (&multilib_obstack, ' ');
6900
        obstack_grow (&multilib_obstack,
6901
                      multilib_defaults_raw[i],
6902
                      strlen (multilib_defaults_raw[i]));
6903
        need_space = TRUE;
6904
      }
6905
 
6906
    obstack_1grow (&multilib_obstack, 0);
6907
    multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6908
  }
6909
 
6910
#ifdef INIT_ENVIRONMENT
6911
  /* Set up any other necessary machine specific environment variables.  */
6912
  xputenv (INIT_ENVIRONMENT);
6913
#endif
6914
 
6915
  /* Make a table of what switches there are (switches, n_switches).
6916
     Make a table of specified input files (infiles, n_infiles).
6917
     Decode switches that are handled locally.  */
6918
 
6919
  process_command (argc, CONST_CAST2 (const char **, char **, argv));
6920
 
6921
  /* Initialize the vector of specs to just the default.
6922
     This means one element containing 0s, as a terminator.  */
6923
 
6924
  compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6925
  memcpy (compilers, default_compilers, sizeof default_compilers);
6926
  n_compilers = n_default_compilers;
6927
 
6928
  /* Read specs from a file if there is one.  */
6929
 
6930
  machine_suffix = concat (spec_machine, dir_separator_str,
6931
                           spec_version, dir_separator_str, NULL);
6932
  just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6933
 
6934
  specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6935
  /* Read the specs file unless it is a default one.  */
6936
  if (specs_file != 0 && strcmp (specs_file, "specs"))
6937
    read_specs (specs_file, TRUE);
6938
  else
6939
    init_spec ();
6940
 
6941
  /* We need to check standard_exec_prefix/just_machine_suffix/specs
6942
     for any override of as, ld and libraries.  */
6943
  specs_file = (char *) alloca (strlen (standard_exec_prefix)
6944
                       + strlen (just_machine_suffix) + sizeof ("specs"));
6945
 
6946
  strcpy (specs_file, standard_exec_prefix);
6947
  strcat (specs_file, just_machine_suffix);
6948
  strcat (specs_file, "specs");
6949
  if (access (specs_file, R_OK) == 0)
6950
    read_specs (specs_file, TRUE);
6951
 
6952
  /* Process any configure-time defaults specified for the command line
6953
     options, via OPTION_DEFAULT_SPECS.  */
6954
  for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6955
    do_option_spec (option_default_specs[i].name,
6956
                    option_default_specs[i].spec);
6957
 
6958
  /* Process DRIVER_SELF_SPECS, adding any new options to the end
6959
     of the command line.  */
6960
 
6961
  for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6962
    do_self_spec (driver_self_specs[i]);
6963
 
6964
  if (compare_debug)
6965
    {
6966
      enum save_temps save;
6967
 
6968
      if (!compare_debug_second)
6969
        {
6970
          n_switches_debug_check[1] = n_switches;
6971
          switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6972
                                             n_switches + 1);
6973
 
6974
          do_self_spec ("%:compare-debug-self-opt()");
6975
          n_switches_debug_check[0] = n_switches;
6976
          switches_debug_check[0] = switches;
6977
 
6978
          n_switches = n_switches_debug_check[1];
6979
          switches = switches_debug_check[1];
6980
        }
6981
 
6982
      /* Avoid crash when computing %j in this early.  */
6983
      save = save_temps_flag;
6984
      save_temps_flag = SAVE_TEMPS_NONE;
6985
 
6986
      compare_debug = -compare_debug;
6987
      do_self_spec ("%:compare-debug-self-opt()");
6988
 
6989
      save_temps_flag = save;
6990
 
6991
      if (!compare_debug_second)
6992
        {
6993
          n_switches_debug_check[1] = n_switches;
6994
          switches_debug_check[1] = switches;
6995
          compare_debug = -compare_debug;
6996
          n_switches = n_switches_debug_check[0];
6997
          switches = switches_debug_check[0];
6998
        }
6999
    }
7000
 
7001
  /* If not cross-compiling, look for executables in the standard
7002
     places.  */
7003
  if (*cross_compile == '0')
7004
    {
7005
      if (*md_exec_prefix)
7006
        {
7007
          add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
7008
                      PREFIX_PRIORITY_LAST, 0, 0);
7009
        }
7010
    }
7011
 
7012
  /* Process sysroot_suffix_spec.  */
7013
  if (*sysroot_suffix_spec != 0
7014
      && do_spec_2 (sysroot_suffix_spec) == 0)
7015
    {
7016
      if (argbuf_index > 1)
7017
        error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7018
      else if (argbuf_index == 1)
7019
        target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
7020
    }
7021
 
7022
#ifdef HAVE_LD_SYSROOT
7023
  /* Pass the --sysroot option to the linker, if it supports that.  If
7024
     there is a sysroot_suffix_spec, it has already been processed by
7025
     this point, so target_system_root really is the system root we
7026
     should be using.  */
7027
  if (target_system_root)
7028
    {
7029
      obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7030
      obstack_grow0 (&obstack, link_spec, strlen (link_spec));
7031
      set_spec ("link", XOBFINISH (&obstack, const char *));
7032
    }
7033
#endif
7034
 
7035
  /* Process sysroot_hdrs_suffix_spec.  */
7036
  if (*sysroot_hdrs_suffix_spec != 0
7037
      && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
7038
    {
7039
      if (argbuf_index > 1)
7040
        error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7041
      else if (argbuf_index == 1)
7042
        target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
7043
    }
7044
 
7045
  /* Look for startfiles in the standard places.  */
7046
  if (*startfile_prefix_spec != 0
7047
      && do_spec_2 (startfile_prefix_spec) == 0
7048
      && do_spec_1 (" ", 0, NULL) == 0)
7049
    {
7050
      int ndx;
7051
      for (ndx = 0; ndx < argbuf_index; ndx++)
7052
        add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
7053
                              PREFIX_PRIORITY_LAST, 0, 1);
7054
    }
7055
  /* We should eventually get rid of all these and stick to
7056
     startfile_prefix_spec exclusively.  */
7057
  else if (*cross_compile == '0' || target_system_root)
7058
    {
7059
      if (*md_startfile_prefix)
7060
        add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
7061
                              "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7062
 
7063
      if (*md_startfile_prefix_1)
7064
        add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
7065
                              "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7066
 
7067
      /* If standard_startfile_prefix is relative, base it on
7068
         standard_exec_prefix.  This lets us move the installed tree
7069
         as a unit.  If GCC_EXEC_PREFIX is defined, base
7070
         standard_startfile_prefix on that as well.
7071
 
7072
         If the prefix is relative, only search it for native compilers;
7073
         otherwise we will search a directory containing host libraries.  */
7074
      if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
7075
        add_sysrooted_prefix (&startfile_prefixes,
7076
                              standard_startfile_prefix, "BINUTILS",
7077
                              PREFIX_PRIORITY_LAST, 0, 1);
7078
      else if (*cross_compile == '0')
7079
        {
7080
          add_prefix (&startfile_prefixes,
7081
                      concat (gcc_exec_prefix
7082
                              ? gcc_exec_prefix : standard_exec_prefix,
7083
                              machine_suffix,
7084
                              standard_startfile_prefix, NULL),
7085
                      NULL, PREFIX_PRIORITY_LAST, 0, 1);
7086
        }
7087
 
7088
      /* Sysrooted prefixes are relocated because target_system_root is
7089
         also relocated by gcc_exec_prefix.  */
7090
      if (*standard_startfile_prefix_1)
7091
        add_sysrooted_prefix (&startfile_prefixes,
7092
                              standard_startfile_prefix_1, "BINUTILS",
7093
                              PREFIX_PRIORITY_LAST, 0, 1);
7094
      if (*standard_startfile_prefix_2)
7095
        add_sysrooted_prefix (&startfile_prefixes,
7096
                              standard_startfile_prefix_2, "BINUTILS",
7097
                              PREFIX_PRIORITY_LAST, 0, 1);
7098
    }
7099
 
7100
  /* Process any user specified specs in the order given on the command
7101
     line.  */
7102
  for (uptr = user_specs_head; uptr; uptr = uptr->next)
7103
    {
7104
      char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7105
                                    R_OK, true);
7106
      read_specs (filename ? filename : uptr->filename, FALSE);
7107
    }
7108
 
7109
  /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
7110
  if (gcc_exec_prefix)
7111
    gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
7112
                              spec_version, dir_separator_str, NULL);
7113
 
7114
  /* Now we have the specs.
7115
     Set the `valid' bits for switches that match anything in any spec.  */
7116
 
7117
  validate_all_switches ();
7118
 
7119
  /* Now that we have the switches and the specs, set
7120
     the subdirectory based on the options.  */
7121
  set_multilib_dir ();
7122
 
7123
  /* Set up to remember the pathname of gcc and any options
7124
     needed for collect.  We use argv[0] instead of programname because
7125
     we need the complete pathname.  */
7126
  obstack_init (&collect_obstack);
7127
  obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7128
  obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
7129
  xputenv (XOBFINISH (&collect_obstack, char *));
7130
 
7131
  /* Set up to remember the pathname of the lto wrapper. */
7132
 
7133
  lto_wrapper_spec = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
7134
  if (lto_wrapper_spec)
7135
    {
7136
      obstack_init (&collect_obstack);
7137
      obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
7138
                    sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7139
      obstack_grow (&collect_obstack, lto_wrapper_spec,
7140
                    strlen (lto_wrapper_spec) + 1);
7141
      xputenv (XOBFINISH (&collect_obstack, char *));
7142
    }
7143
 
7144
  /* Warn about any switches that no pass was interested in.  */
7145
 
7146
  for (i = 0; (int) i < n_switches; i++)
7147
    if (! switches[i].validated)
7148
      error ("unrecognized option '-%s'", switches[i].part1);
7149
 
7150
  /* Obey some of the options.  */
7151
 
7152
  if (print_search_dirs)
7153
    {
7154
      printf (_("install: %s%s\n"),
7155
              gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7156
              gcc_exec_prefix ? "" : machine_suffix);
7157
      printf (_("programs: %s\n"),
7158
              build_search_list (&exec_prefixes, "", false, false));
7159
      printf (_("libraries: %s\n"),
7160
              build_search_list (&startfile_prefixes, "", false, true));
7161
      return (0);
7162
    }
7163
 
7164
  if (print_file_name)
7165
    {
7166
      printf ("%s\n", find_file (print_file_name));
7167
      return (0);
7168
    }
7169
 
7170
  if (print_prog_name)
7171
    {
7172
      char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7173
      printf ("%s\n", (newname ? newname : print_prog_name));
7174
      return (0);
7175
    }
7176
 
7177
  if (print_multi_lib)
7178
    {
7179
      print_multilib_info ();
7180
      return (0);
7181
    }
7182
 
7183
  if (print_multi_directory)
7184
    {
7185
      if (multilib_dir == NULL)
7186
        printf (".\n");
7187
      else
7188
        printf ("%s\n", multilib_dir);
7189
      return (0);
7190
    }
7191
 
7192
  if (print_sysroot)
7193
    {
7194
      if (target_system_root)
7195
        {
7196
          if (target_sysroot_suffix)
7197
            printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7198
          else
7199
            printf ("%s\n", target_system_root);
7200
        }
7201
      return (0);
7202
    }
7203
 
7204
  if (print_multi_os_directory)
7205
    {
7206
      if (multilib_os_dir == NULL)
7207
        printf (".\n");
7208
      else
7209
        printf ("%s\n", multilib_os_dir);
7210
      return (0);
7211
    }
7212
 
7213
  if (print_sysroot_headers_suffix)
7214
    {
7215
      if (*sysroot_hdrs_suffix_spec)
7216
        {
7217
          printf("%s\n", (target_sysroot_hdrs_suffix
7218
                          ? target_sysroot_hdrs_suffix
7219
                          : ""));
7220
          return (0);
7221
        }
7222
      else
7223
        /* The error status indicates that only one set of fixed
7224
           headers should be built.  */
7225
        fatal ("not configured with sysroot headers suffix");
7226
    }
7227
 
7228
  if (print_help_list)
7229
    {
7230
      display_help ();
7231
 
7232
      if (! verbose_flag)
7233
        {
7234
          printf (_("\nFor bug reporting instructions, please see:\n"));
7235
          printf ("%s.\n", bug_report_url);
7236
 
7237
          return (0);
7238
        }
7239
 
7240
      /* We do not exit here.  Instead we have created a fake input file
7241
         called 'help-dummy' which needs to be compiled, and we pass this
7242
         on the various sub-processes, along with the --help switch.
7243
         Ensure their output appears after ours.  */
7244
      fputc ('\n', stdout);
7245
      fflush (stdout);
7246
    }
7247
 
7248
  if (print_version)
7249
    {
7250
      printf (_("%s %s%s\n"), programname, pkgversion_string,
7251
              version_string);
7252
      printf ("Copyright %s 2010 Free Software Foundation, Inc.\n",
7253
              _("(C)"));
7254
      fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
7255
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7256
             stdout);
7257
      if (! verbose_flag)
7258
        return 0;
7259
 
7260
      /* We do not exit here. We use the same mechanism of --help to print
7261
         the version of the sub-processes. */
7262
      fputc ('\n', stdout);
7263
      fflush (stdout);
7264
    }
7265
 
7266
  if (verbose_flag)
7267
    {
7268
      int n;
7269
      const char *thrmod;
7270
 
7271
      notice ("Target: %s\n", spec_machine);
7272
      notice ("Configured with: %s\n", configuration_arguments);
7273
 
7274
#ifdef THREAD_MODEL_SPEC
7275
      /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7276
         but there's no point in doing all this processing just to get
7277
         thread_model back.  */
7278
      obstack_init (&obstack);
7279
      do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7280
      obstack_1grow (&obstack, '\0');
7281
      thrmod = XOBFINISH (&obstack, const char *);
7282
#else
7283
      thrmod = thread_model;
7284
#endif
7285
 
7286
      notice ("Thread model: %s\n", thrmod);
7287
 
7288
      /* compiler_version is truncated at the first space when initialized
7289
         from version string, so truncate version_string at the first space
7290
         before comparing.  */
7291
      for (n = 0; version_string[n]; n++)
7292
        if (version_string[n] == ' ')
7293
          break;
7294
 
7295
      if (! strncmp (version_string, compiler_version, n)
7296
          && compiler_version[n] == 0)
7297
        notice ("gcc version %s %s\n", version_string, pkgversion_string);
7298
      else
7299
        notice ("gcc driver version %s %sexecuting gcc version %s\n",
7300
                version_string, pkgversion_string, compiler_version);
7301
 
7302
      if (n_infiles == 0)
7303
        return (0);
7304
    }
7305
 
7306
  if (n_infiles == added_libraries)
7307
    fatal ("no input files");
7308
 
7309
  /* Make a place to record the compiler output file names
7310
     that correspond to the input files.  */
7311
 
7312
  i = n_infiles;
7313
  i += lang_specific_extra_outfiles;
7314
  outfiles = XCNEWVEC (const char *, i);
7315
 
7316
  /* Record which files were specified explicitly as link input.  */
7317
 
7318
  explicit_link_files = XCNEWVEC (char, n_infiles);
7319
 
7320
  if (combine_flag)
7321
    combine_inputs = true;
7322
  else
7323
    combine_inputs = false;
7324
 
7325
  for (i = 0; (int) i < n_infiles; i++)
7326
    {
7327
      const char *name = infiles[i].name;
7328
      struct compiler *compiler = lookup_compiler (name,
7329
                                                   strlen (name),
7330
                                                   infiles[i].language);
7331
 
7332
      if (compiler && !(compiler->combinable))
7333
        combine_inputs = false;
7334
 
7335
      if (lang_n_infiles > 0 && compiler != input_file_compiler
7336
          && infiles[i].language && infiles[i].language[0] != '*')
7337
        infiles[i].incompiler = compiler;
7338
      else if (compiler)
7339
        {
7340
          lang_n_infiles++;
7341
          input_file_compiler = compiler;
7342
          infiles[i].incompiler = compiler;
7343
        }
7344
      else
7345
        {
7346
          /* Since there is no compiler for this input file, assume it is a
7347
             linker file.  */
7348
          explicit_link_files[i] = 1;
7349
          infiles[i].incompiler = NULL;
7350
        }
7351
      infiles[i].compiled = false;
7352
      infiles[i].preprocessed = false;
7353
    }
7354
 
7355
  if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7356
   fatal ("cannot specify -o with -c, -S or -E with multiple files");
7357
 
7358
  if (combine_flag && save_temps_flag)
7359
    {
7360
      bool save_combine_inputs = combine_inputs;
7361
      /* Must do a separate pre-processing pass for C & Objective-C files, to
7362
         obtain individual .i files.  */
7363
 
7364
      combine_inputs = false;
7365
      for (i = 0; (int) i < n_infiles; i++)
7366
        {
7367
          int this_file_error = 0;
7368
 
7369
          input_file_number = i;
7370
          set_input (infiles[i].name);
7371
          if (infiles[i].incompiler
7372
              && (infiles[i].incompiler)->needs_preprocessing)
7373
            input_file_compiler = infiles[i].incompiler;
7374
          else
7375
            continue;
7376
 
7377
          if (input_file_compiler)
7378
            {
7379
              if (input_file_compiler->spec[0] == '#')
7380
                {
7381
                  error ("%s: %s compiler not installed on this system",
7382
                         input_filename, &input_file_compiler->spec[1]);
7383
                  this_file_error = 1;
7384
                }
7385
              else
7386
                {
7387
                  value = do_spec (input_file_compiler->spec);
7388
                  infiles[i].preprocessed = true;
7389
                  if (!have_o_argbuf_index)
7390
                    fatal ("spec '%s' is invalid", input_file_compiler->spec);
7391
                  infiles[i].name = argbuf[have_o_argbuf_index];
7392
                  infiles[i].incompiler
7393
                    = lookup_compiler (infiles[i].name,
7394
                                       strlen (infiles[i].name),
7395
                                       infiles[i].language);
7396
 
7397
                  if (value < 0)
7398
                    this_file_error = 1;
7399
                }
7400
            }
7401
 
7402
          if (this_file_error)
7403
            {
7404
              delete_failure_queue ();
7405
              error_count++;
7406
              break;
7407
            }
7408
          clear_failure_queue ();
7409
        }
7410
      combine_inputs = save_combine_inputs;
7411
    }
7412
 
7413
  for (i = 0; (int) i < n_infiles; i++)
7414
    {
7415
      int this_file_error = 0;
7416
 
7417
      /* Tell do_spec what to substitute for %i.  */
7418
 
7419
      input_file_number = i;
7420
      set_input (infiles[i].name);
7421
 
7422
      if (infiles[i].compiled)
7423
        continue;
7424
 
7425
      /* Use the same thing in %o, unless cp->spec says otherwise.  */
7426
 
7427
      outfiles[i] = input_filename;
7428
 
7429
      /* Figure out which compiler from the file's suffix.  */
7430
 
7431
      if (! combine_inputs)
7432
        input_file_compiler
7433
          = lookup_compiler (infiles[i].name, input_filename_length,
7434
                             infiles[i].language);
7435
      else
7436
        input_file_compiler = infiles[i].incompiler;
7437
 
7438
      if (input_file_compiler)
7439
        {
7440
          /* Ok, we found an applicable compiler.  Run its spec.  */
7441
 
7442
          if (input_file_compiler->spec[0] == '#')
7443
            {
7444
              error ("%s: %s compiler not installed on this system",
7445
                     input_filename, &input_file_compiler->spec[1]);
7446
              this_file_error = 1;
7447
            }
7448
          else
7449
            {
7450
              if (compare_debug)
7451
                {
7452
                  if (debug_check_temp_file[0])
7453
                    free (debug_check_temp_file[0]);
7454
                  debug_check_temp_file[0] = NULL;
7455
 
7456
                  if (debug_check_temp_file[1])
7457
                    free (debug_check_temp_file[1]);
7458
                  debug_check_temp_file[1] = NULL;
7459
                }
7460
 
7461
              value = do_spec (input_file_compiler->spec);
7462
              infiles[i].compiled = true;
7463
              if (value < 0)
7464
                this_file_error = 1;
7465
              else if (compare_debug && debug_check_temp_file[0])
7466
                {
7467
                  if (verbose_flag)
7468
                    error ("Recompiling with -fcompare-debug");
7469
 
7470
                  compare_debug = -compare_debug;
7471
                  n_switches = n_switches_debug_check[1];
7472
                  switches = switches_debug_check[1];
7473
 
7474
                  value = do_spec (input_file_compiler->spec);
7475
 
7476
                  compare_debug = -compare_debug;
7477
                  n_switches = n_switches_debug_check[0];
7478
                  switches = switches_debug_check[0];
7479
 
7480
                  if (value < 0)
7481
                    {
7482
                      error ("during -fcompare-debug recompilation");
7483
                      this_file_error = 1;
7484
                    }
7485
 
7486
                  gcc_assert (debug_check_temp_file[1]
7487
                              && strcmp (debug_check_temp_file[0],
7488
                                         debug_check_temp_file[1]));
7489
 
7490
                  if (verbose_flag)
7491
                    error ("Comparing final insns dumps");
7492
 
7493
                  if (compare_files (debug_check_temp_file))
7494
                    this_file_error = 1;
7495
                }
7496
 
7497
              if (compare_debug)
7498
                {
7499
                  if (debug_check_temp_file[0])
7500
                    free (debug_check_temp_file[0]);
7501
                  debug_check_temp_file[0] = NULL;
7502
 
7503
                  if (debug_check_temp_file[1])
7504
                    free (debug_check_temp_file[1]);
7505
                  debug_check_temp_file[1] = NULL;
7506
                }
7507
            }
7508
        }
7509
 
7510
      /* If this file's name does not contain a recognized suffix,
7511
         record it as explicit linker input.  */
7512
 
7513
      else
7514
        explicit_link_files[i] = 1;
7515
 
7516
      /* Clear the delete-on-failure queue, deleting the files in it
7517
         if this compilation failed.  */
7518
 
7519
      if (this_file_error)
7520
        {
7521
          delete_failure_queue ();
7522
          error_count++;
7523
        }
7524
      /* If this compilation succeeded, don't delete those files later.  */
7525
      clear_failure_queue ();
7526
    }
7527
 
7528
  /* Reset the input file name to the first compile/object file name, for use
7529
     with %b in LINK_SPEC. We use the first input file that we can find
7530
     a compiler to compile it instead of using infiles.language since for
7531
     languages other than C we use aliases that we then lookup later.  */
7532
  if (n_infiles > 0)
7533
    {
7534
      int i;
7535
 
7536
      for (i = 0; i < n_infiles ; i++)
7537
        if (infiles[i].language && infiles[i].language[0] != '*')
7538
          {
7539
            set_input (infiles[i].name);
7540
            break;
7541
          }
7542
    }
7543
 
7544
  if (error_count == 0)
7545
    {
7546
      /* Make sure INPUT_FILE_NUMBER points to first available open
7547
         slot.  */
7548
      input_file_number = n_infiles;
7549
      if (lang_specific_pre_link ())
7550
        error_count++;
7551
    }
7552
 
7553
  /* Determine if there are any linker input files.  */
7554
  num_linker_inputs = 0;
7555
  for (i = 0; (int) i < n_infiles; i++)
7556
    if (explicit_link_files[i] || outfiles[i] != NULL)
7557
      num_linker_inputs++;
7558
 
7559
  /* Run ld to link all the compiler output files.  */
7560
 
7561
  if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
7562
    {
7563
      int tmp = execution_count;
7564
      const char *fuse_linker_plugin = "fuse-linker-plugin";
7565
 
7566
      /* We'll use ld if we can't find collect2.  */
7567
      if (! strcmp (linker_name_spec, "collect2"))
7568
        {
7569
          char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7570
          if (s == NULL)
7571
            linker_name_spec = "ld";
7572
        }
7573
 
7574
      if (switch_matches (fuse_linker_plugin,
7575
                          fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
7576
        {
7577
          linker_plugin_file_spec = find_a_file (&exec_prefixes,
7578
                                                 "liblto_plugin.so", R_OK,
7579
                                                 false);
7580
          if (!linker_plugin_file_spec)
7581
            fatal ("-fuse-linker-plugin, but liblto_plugin.so not found");
7582
 
7583
          lto_libgcc_spec = find_a_file (&startfile_prefixes, "libgcc.a",
7584
                                         R_OK, true);
7585
          if (!lto_libgcc_spec)
7586
            fatal ("could not find libgcc.a");
7587
        }
7588
      lto_gcc_spec = argv[0];
7589
 
7590
      /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7591
         for collect.  */
7592
      putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7593
      putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7594
 
7595
      if (print_subprocess_help == 1)
7596
        {
7597
          printf (_("\nLinker options\n==============\n\n"));
7598
          printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7599
                    " to the linker.\n\n"));
7600
          fflush (stdout);
7601
        }
7602
      value = do_spec (link_command_spec);
7603
      if (value < 0)
7604
        error_count = 1;
7605
      linker_was_run = (tmp != execution_count);
7606
    }
7607
 
7608
  /* If options said don't run linker,
7609
     complain about input files to be given to the linker.  */
7610
 
7611
  if (! linker_was_run && error_count == 0)
7612
    for (i = 0; (int) i < n_infiles; i++)
7613
      if (explicit_link_files[i]
7614
          && !(infiles[i].language && infiles[i].language[0] == '*'))
7615
        error ("%s: linker input file unused because linking not done",
7616
               outfiles[i]);
7617
 
7618
  /* Delete some or all of the temporary files we made.  */
7619
 
7620
  if (error_count)
7621
    delete_failure_queue ();
7622
  delete_temp_files ();
7623
 
7624
  if (print_help_list)
7625
    {
7626
      printf (("\nFor bug reporting instructions, please see:\n"));
7627
      printf ("%s\n", bug_report_url);
7628
    }
7629
 
7630
  return (signal_count != 0 ? 2
7631
          : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
7632
          : 0);
7633
}
7634
 
7635
/* Find the proper compilation spec for the file name NAME,
7636
   whose length is LENGTH.  LANGUAGE is the specified language,
7637
   or 0 if this file is to be passed to the linker.  */
7638
 
7639
static struct compiler *
7640
lookup_compiler (const char *name, size_t length, const char *language)
7641
{
7642
  struct compiler *cp;
7643
 
7644
  /* If this was specified by the user to be a linker input, indicate that.  */
7645
  if (language != 0 && language[0] == '*')
7646
    return 0;
7647
 
7648
  /* Otherwise, look for the language, if one is spec'd.  */
7649
  if (language != 0)
7650
    {
7651
      for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7652
        if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7653
          return cp;
7654
 
7655
      error ("language %s not recognized", language);
7656
      return 0;
7657
    }
7658
 
7659
  /* Look for a suffix.  */
7660
  for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7661
    {
7662
      if (/* The suffix `-' matches only the file name `-'.  */
7663
          (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7664
          || (strlen (cp->suffix) < length
7665
              /* See if the suffix matches the end of NAME.  */
7666
              && !strcmp (cp->suffix,
7667
                          name + length - strlen (cp->suffix))
7668
         ))
7669
        break;
7670
    }
7671
 
7672
#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7673
  /* Look again, but case-insensitively this time.  */
7674
  if (cp < compilers)
7675
    for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7676
      {
7677
        if (/* The suffix `-' matches only the file name `-'.  */
7678
            (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7679
            || (strlen (cp->suffix) < length
7680
                /* See if the suffix matches the end of NAME.  */
7681
                && ((!strcmp (cp->suffix,
7682
                             name + length - strlen (cp->suffix))
7683
                     || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7684
                    && !strcasecmp (cp->suffix,
7685
                                    name + length - strlen (cp->suffix)))
7686
           ))
7687
          break;
7688
      }
7689
#endif
7690
 
7691
  if (cp >= compilers)
7692
    {
7693
      if (cp->spec[0] != '@')
7694
        /* A non-alias entry: return it.  */
7695
        return cp;
7696
 
7697
      /* An alias entry maps a suffix to a language.
7698
         Search for the language; pass 0 for NAME and LENGTH
7699
         to avoid infinite recursion if language not found.  */
7700
      return lookup_compiler (NULL, 0, cp->spec + 1);
7701
    }
7702
  return 0;
7703
}
7704
 
7705
static char *
7706
save_string (const char *s, int len)
7707
{
7708
  char *result = XNEWVEC (char, len + 1);
7709
 
7710
  memcpy (result, s, len);
7711
  result[len] = 0;
7712
  return result;
7713
}
7714
 
7715
void
7716
pfatal_with_name (const char *name)
7717
{
7718
  perror_with_name (name);
7719
  delete_temp_files ();
7720
  exit (1);
7721
}
7722
 
7723
static void
7724
perror_with_name (const char *name)
7725
{
7726
  error ("%s: %s", name, xstrerror (errno));
7727
}
7728
 
7729
/* Output an error message and exit.  */
7730
 
7731
void
7732
fancy_abort (const char *file, int line, const char *func)
7733
{
7734
  fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
7735
}
7736
 
7737
/* Output an error message and exit.  */
7738
 
7739
void
7740
fatal_ice (const char *cmsgid, ...)
7741
{
7742
  va_list ap;
7743
 
7744
  va_start (ap, cmsgid);
7745
 
7746
  fprintf (stderr, "%s: ", programname);
7747
  vfprintf (stderr, _(cmsgid), ap);
7748
  va_end (ap);
7749
  fprintf (stderr, "\n");
7750
  delete_temp_files ();
7751
  exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
7752
}
7753
 
7754
void
7755
fatal (const char *cmsgid, ...)
7756
{
7757
  va_list ap;
7758
 
7759
  va_start (ap, cmsgid);
7760
 
7761
  fprintf (stderr, "%s: ", programname);
7762
  vfprintf (stderr, _(cmsgid), ap);
7763
  va_end (ap);
7764
  fprintf (stderr, "\n");
7765
  delete_temp_files ();
7766
  exit (1);
7767
}
7768
 
7769
/* The argument is actually c-format, not gcc-internal-format,
7770
   but because functions with identical names are used through
7771
   the rest of the compiler with gcc-internal-format, we just
7772
   need to hope all users of these functions use the common
7773
   subset between c-format and gcc-internal-format.  */
7774
 
7775
void
7776
error (const char *gmsgid, ...)
7777
{
7778
  va_list ap;
7779
 
7780
  va_start (ap, gmsgid);
7781
  fprintf (stderr, "%s: ", programname);
7782
  vfprintf (stderr, _(gmsgid), ap);
7783
  va_end (ap);
7784
 
7785
  fprintf (stderr, "\n");
7786
}
7787
 
7788
static void
7789
notice (const char *cmsgid, ...)
7790
{
7791
  va_list ap;
7792
 
7793
  va_start (ap, cmsgid);
7794
  vfprintf (stderr, _(cmsgid), ap);
7795
  va_end (ap);
7796
}
7797
 
7798
static inline void
7799
validate_switches_from_spec (const char *spec)
7800
{
7801
  const char *p = spec;
7802
  char c;
7803
  while ((c = *p++))
7804
    if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7805
      /* We have a switch spec.  */
7806
      p = validate_switches (p + 1);
7807
}
7808
 
7809
static void
7810
validate_all_switches (void)
7811
{
7812
  struct compiler *comp;
7813
  struct spec_list *spec;
7814
 
7815
  for (comp = compilers; comp->spec; comp++)
7816
    validate_switches_from_spec (comp->spec);
7817
 
7818
  /* Look through the linked list of specs read from the specs file.  */
7819
  for (spec = specs; spec; spec = spec->next)
7820
    validate_switches_from_spec (*spec->ptr_spec);
7821
 
7822
  validate_switches_from_spec (link_command_spec);
7823
}
7824
 
7825
/* Look at the switch-name that comes after START
7826
   and mark as valid all supplied switches that match it.  */
7827
 
7828
static const char *
7829
validate_switches (const char *start)
7830
{
7831
  const char *p = start;
7832
  const char *atom;
7833
  size_t len;
7834
  int i;
7835
  bool suffix = false;
7836
  bool starred = false;
7837
 
7838
#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7839
 
7840
next_member:
7841
  SKIP_WHITE ();
7842
 
7843
  if (*p == '!')
7844
    p++;
7845
 
7846
  SKIP_WHITE ();
7847
  if (*p == '.' || *p == ',')
7848
    suffix = true, p++;
7849
 
7850
  atom = p;
7851
  while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7852
         || *p == ',' || *p == '.' || *p == '@')
7853
    p++;
7854
  len = p - atom;
7855
 
7856
  if (*p == '*')
7857
    starred = true, p++;
7858
 
7859
  SKIP_WHITE ();
7860
 
7861
  if (!suffix)
7862
    {
7863
      /* Mark all matching switches as valid.  */
7864
      for (i = 0; i < n_switches; i++)
7865
        if (!strncmp (switches[i].part1, atom, len)
7866
            && (starred || switches[i].part1[len] == 0))
7867
          switches[i].validated = 1;
7868
    }
7869
 
7870
  if (*p) p++;
7871
  if (*p && (p[-1] == '|' || p[-1] == '&'))
7872
    goto next_member;
7873
 
7874
  if (*p && p[-1] == ':')
7875
    {
7876
      while (*p && *p != ';' && *p != '}')
7877
        {
7878
          if (*p == '%')
7879
            {
7880
              p++;
7881
              if (*p == '{' || *p == '<')
7882
                p = validate_switches (p+1);
7883
              else if (p[0] == 'W' && p[1] == '{')
7884
                p = validate_switches (p+2);
7885
            }
7886
          else
7887
            p++;
7888
        }
7889
 
7890
      if (*p) p++;
7891
      if (*p && p[-1] == ';')
7892
        goto next_member;
7893
    }
7894
 
7895
  return p;
7896
#undef SKIP_WHITE
7897
}
7898
 
7899
struct mdswitchstr
7900
{
7901
  const char *str;
7902
  int len;
7903
};
7904
 
7905
static struct mdswitchstr *mdswitches;
7906
static int n_mdswitches;
7907
 
7908
/* Check whether a particular argument was used.  The first time we
7909
   canonicalize the switches to keep only the ones we care about.  */
7910
 
7911
static int
7912
used_arg (const char *p, int len)
7913
{
7914
  struct mswitchstr
7915
  {
7916
    const char *str;
7917
    const char *replace;
7918
    int len;
7919
    int rep_len;
7920
  };
7921
 
7922
  static struct mswitchstr *mswitches;
7923
  static int n_mswitches;
7924
  int i, j;
7925
 
7926
  if (!mswitches)
7927
    {
7928
      struct mswitchstr *matches;
7929
      const char *q;
7930
      int cnt = 0;
7931
 
7932
      /* Break multilib_matches into the component strings of string
7933
         and replacement string.  */
7934
      for (q = multilib_matches; *q != '\0'; q++)
7935
        if (*q == ';')
7936
          cnt++;
7937
 
7938
      matches
7939
        = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7940
      i = 0;
7941
      q = multilib_matches;
7942
      while (*q != '\0')
7943
        {
7944
          matches[i].str = q;
7945
          while (*q != ' ')
7946
            {
7947
              if (*q == '\0')
7948
                {
7949
                invalid_matches:
7950
                  fatal ("multilib spec '%s' is invalid", multilib_matches);
7951
                }
7952
              q++;
7953
            }
7954
          matches[i].len = q - matches[i].str;
7955
 
7956
          matches[i].replace = ++q;
7957
          while (*q != ';' && *q != '\0')
7958
            {
7959
              if (*q == ' ')
7960
                goto invalid_matches;
7961
              q++;
7962
            }
7963
          matches[i].rep_len = q - matches[i].replace;
7964
          i++;
7965
          if (*q == ';')
7966
            q++;
7967
        }
7968
 
7969
      /* Now build a list of the replacement string for switches that we care
7970
         about.  Make sure we allocate at least one entry.  This prevents
7971
         xmalloc from calling fatal, and prevents us from re-executing this
7972
         block of code.  */
7973
      mswitches
7974
        = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7975
      for (i = 0; i < n_switches; i++)
7976
        if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7977
          {
7978
            int xlen = strlen (switches[i].part1);
7979
            for (j = 0; j < cnt; j++)
7980
              if (xlen == matches[j].len
7981
                  && ! strncmp (switches[i].part1, matches[j].str, xlen))
7982
                {
7983
                  mswitches[n_mswitches].str = matches[j].replace;
7984
                  mswitches[n_mswitches].len = matches[j].rep_len;
7985
                  mswitches[n_mswitches].replace = (char *) 0;
7986
                  mswitches[n_mswitches].rep_len = 0;
7987
                  n_mswitches++;
7988
                  break;
7989
                }
7990
          }
7991
 
7992
      /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7993
         on the command line nor any options mutually incompatible with
7994
         them.  */
7995
      for (i = 0; i < n_mdswitches; i++)
7996
        {
7997
          const char *r;
7998
 
7999
          for (q = multilib_options; *q != '\0'; q++)
8000
            {
8001
              while (*q == ' ')
8002
                q++;
8003
 
8004
              r = q;
8005
              while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
8006
                     || strchr (" /", q[mdswitches[i].len]) == NULL)
8007
                {
8008
                  while (*q != ' ' && *q != '/' && *q != '\0')
8009
                    q++;
8010
                  if (*q != '/')
8011
                    break;
8012
                  q++;
8013
                }
8014
 
8015
              if (*q != ' ' && *q != '\0')
8016
                {
8017
                  while (*r != ' ' && *r != '\0')
8018
                    {
8019
                      q = r;
8020
                      while (*q != ' ' && *q != '/' && *q != '\0')
8021
                        q++;
8022
 
8023
                      if (used_arg (r, q - r))
8024
                        break;
8025
 
8026
                      if (*q != '/')
8027
                        {
8028
                          mswitches[n_mswitches].str = mdswitches[i].str;
8029
                          mswitches[n_mswitches].len = mdswitches[i].len;
8030
                          mswitches[n_mswitches].replace = (char *) 0;
8031
                          mswitches[n_mswitches].rep_len = 0;
8032
                          n_mswitches++;
8033
                          break;
8034
                        }
8035
 
8036
                      r = q + 1;
8037
                    }
8038
                  break;
8039
                }
8040
            }
8041
        }
8042
    }
8043
 
8044
  for (i = 0; i < n_mswitches; i++)
8045
    if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
8046
      return 1;
8047
 
8048
  return 0;
8049
}
8050
 
8051
static int
8052
default_arg (const char *p, int len)
8053
{
8054
  int i;
8055
 
8056
  for (i = 0; i < n_mdswitches; i++)
8057
    if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
8058
      return 1;
8059
 
8060
  return 0;
8061
}
8062
 
8063
/* Work out the subdirectory to use based on the options. The format of
8064
   multilib_select is a list of elements. Each element is a subdirectory
8065
   name followed by a list of options followed by a semicolon. The format
8066
   of multilib_exclusions is the same, but without the preceding
8067
   directory. First gcc will check the exclusions, if none of the options
8068
   beginning with an exclamation point are present, and all of the other
8069
   options are present, then we will ignore this completely. Passing
8070
   that, gcc will consider each multilib_select in turn using the same
8071
   rules for matching the options. If a match is found, that subdirectory
8072
   will be used.  */
8073
 
8074
static void
8075
set_multilib_dir (void)
8076
{
8077
  const char *p;
8078
  unsigned int this_path_len;
8079
  const char *this_path, *this_arg;
8080
  const char *start, *end;
8081
  int not_arg;
8082
  int ok, ndfltok, first;
8083
 
8084
  n_mdswitches = 0;
8085
  start = multilib_defaults;
8086
  while (*start == ' ' || *start == '\t')
8087
    start++;
8088
  while (*start != '\0')
8089
    {
8090
      n_mdswitches++;
8091
      while (*start != ' ' && *start != '\t' && *start != '\0')
8092
        start++;
8093
      while (*start == ' ' || *start == '\t')
8094
        start++;
8095
    }
8096
 
8097
  if (n_mdswitches)
8098
    {
8099
      int i = 0;
8100
 
8101
      mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
8102
      for (start = multilib_defaults; *start != '\0'; start = end + 1)
8103
        {
8104
          while (*start == ' ' || *start == '\t')
8105
            start++;
8106
 
8107
          if (*start == '\0')
8108
            break;
8109
 
8110
          for (end = start + 1;
8111
               *end != ' ' && *end != '\t' && *end != '\0'; end++)
8112
            ;
8113
 
8114
          obstack_grow (&multilib_obstack, start, end - start);
8115
          obstack_1grow (&multilib_obstack, 0);
8116
          mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
8117
          mdswitches[i++].len = end - start;
8118
 
8119
          if (*end == '\0')
8120
            break;
8121
        }
8122
    }
8123
 
8124
  p = multilib_exclusions;
8125
  while (*p != '\0')
8126
    {
8127
      /* Ignore newlines.  */
8128
      if (*p == '\n')
8129
        {
8130
          ++p;
8131
          continue;
8132
        }
8133
 
8134
      /* Check the arguments.  */
8135
      ok = 1;
8136
      while (*p != ';')
8137
        {
8138
          if (*p == '\0')
8139
            {
8140
            invalid_exclusions:
8141
              fatal ("multilib exclusions '%s' is invalid",
8142
                     multilib_exclusions);
8143
            }
8144
 
8145
          if (! ok)
8146
            {
8147
              ++p;
8148
              continue;
8149
            }
8150
 
8151
          this_arg = p;
8152
          while (*p != ' ' && *p != ';')
8153
            {
8154
              if (*p == '\0')
8155
                goto invalid_exclusions;
8156
              ++p;
8157
            }
8158
 
8159
          if (*this_arg != '!')
8160
            not_arg = 0;
8161
          else
8162
            {
8163
              not_arg = 1;
8164
              ++this_arg;
8165
            }
8166
 
8167
          ok = used_arg (this_arg, p - this_arg);
8168
          if (not_arg)
8169
            ok = ! ok;
8170
 
8171
          if (*p == ' ')
8172
            ++p;
8173
        }
8174
 
8175
      if (ok)
8176
        return;
8177
 
8178
      ++p;
8179
    }
8180
 
8181
  first = 1;
8182
  p = multilib_select;
8183
  while (*p != '\0')
8184
    {
8185
      /* Ignore newlines.  */
8186
      if (*p == '\n')
8187
        {
8188
          ++p;
8189
          continue;
8190
        }
8191
 
8192
      /* Get the initial path.  */
8193
      this_path = p;
8194
      while (*p != ' ')
8195
        {
8196
          if (*p == '\0')
8197
            {
8198
            invalid_select:
8199
              fatal ("multilib select '%s' is invalid",
8200
                     multilib_select);
8201
            }
8202
          ++p;
8203
        }
8204
      this_path_len = p - this_path;
8205
 
8206
      /* Check the arguments.  */
8207
      ok = 1;
8208
      ndfltok = 1;
8209
      ++p;
8210
      while (*p != ';')
8211
        {
8212
          if (*p == '\0')
8213
            goto invalid_select;
8214
 
8215
          if (! ok)
8216
            {
8217
              ++p;
8218
              continue;
8219
            }
8220
 
8221
          this_arg = p;
8222
          while (*p != ' ' && *p != ';')
8223
            {
8224
              if (*p == '\0')
8225
                goto invalid_select;
8226
              ++p;
8227
            }
8228
 
8229
          if (*this_arg != '!')
8230
            not_arg = 0;
8231
          else
8232
            {
8233
              not_arg = 1;
8234
              ++this_arg;
8235
            }
8236
 
8237
          /* If this is a default argument, we can just ignore it.
8238
             This is true even if this_arg begins with '!'.  Beginning
8239
             with '!' does not mean that this argument is necessarily
8240
             inappropriate for this library: it merely means that
8241
             there is a more specific library which uses this
8242
             argument.  If this argument is a default, we need not
8243
             consider that more specific library.  */
8244
          ok = used_arg (this_arg, p - this_arg);
8245
          if (not_arg)
8246
            ok = ! ok;
8247
 
8248
          if (! ok)
8249
            ndfltok = 0;
8250
 
8251
          if (default_arg (this_arg, p - this_arg))
8252
            ok = 1;
8253
 
8254
          if (*p == ' ')
8255
            ++p;
8256
        }
8257
 
8258
      if (ok && first)
8259
        {
8260
          if (this_path_len != 1
8261
              || this_path[0] != '.')
8262
            {
8263
              char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8264
              char *q;
8265
 
8266
              strncpy (new_multilib_dir, this_path, this_path_len);
8267
              new_multilib_dir[this_path_len] = '\0';
8268
              q = strchr (new_multilib_dir, ':');
8269
              if (q != NULL)
8270
                *q = '\0';
8271
              multilib_dir = new_multilib_dir;
8272
            }
8273
          first = 0;
8274
        }
8275
 
8276
      if (ndfltok)
8277
        {
8278
          const char *q = this_path, *end = this_path + this_path_len;
8279
 
8280
          while (q < end && *q != ':')
8281
            q++;
8282
          if (q < end)
8283
            {
8284
              char *new_multilib_os_dir = XNEWVEC (char, end - q);
8285
              memcpy (new_multilib_os_dir, q + 1, end - q - 1);
8286
              new_multilib_os_dir[end - q - 1] = '\0';
8287
              multilib_os_dir = new_multilib_os_dir;
8288
              break;
8289
            }
8290
        }
8291
 
8292
      ++p;
8293
    }
8294
 
8295
  if (multilib_dir == NULL && multilib_os_dir != NULL
8296
      && strcmp (multilib_os_dir, ".") == 0)
8297
    {
8298
      free (CONST_CAST (char *, multilib_os_dir));
8299
      multilib_os_dir = NULL;
8300
    }
8301
  else if (multilib_dir != NULL && multilib_os_dir == NULL)
8302
    multilib_os_dir = multilib_dir;
8303
}
8304
 
8305
/* Print out the multiple library subdirectory selection
8306
   information.  This prints out a series of lines.  Each line looks
8307
   like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8308
   required.  Only the desired options are printed out, the negative
8309
   matches.  The options are print without a leading dash.  There are
8310
   no spaces to make it easy to use the information in the shell.
8311
   Each subdirectory is printed only once.  This assumes the ordering
8312
   generated by the genmultilib script. Also, we leave out ones that match
8313
   the exclusions.  */
8314
 
8315
static void
8316
print_multilib_info (void)
8317
{
8318
  const char *p = multilib_select;
8319
  const char *last_path = 0, *this_path;
8320
  int skip;
8321
  unsigned int last_path_len = 0;
8322
 
8323
  while (*p != '\0')
8324
    {
8325
      skip = 0;
8326
      /* Ignore newlines.  */
8327
      if (*p == '\n')
8328
        {
8329
          ++p;
8330
          continue;
8331
        }
8332
 
8333
      /* Get the initial path.  */
8334
      this_path = p;
8335
      while (*p != ' ')
8336
        {
8337
          if (*p == '\0')
8338
            {
8339
            invalid_select:
8340
              fatal ("multilib select '%s' is invalid", multilib_select);
8341
            }
8342
 
8343
          ++p;
8344
        }
8345
 
8346
      /* When --disable-multilib was used but target defines
8347
         MULTILIB_OSDIRNAMES, entries starting with .: are there just
8348
         to find multilib_os_dir, so skip them from output.  */
8349
      if (this_path[0] == '.' && this_path[1] == ':')
8350
        skip = 1;
8351
 
8352
      /* Check for matches with the multilib_exclusions. We don't bother
8353
         with the '!' in either list. If any of the exclusion rules match
8354
         all of its options with the select rule, we skip it.  */
8355
      {
8356
        const char *e = multilib_exclusions;
8357
        const char *this_arg;
8358
 
8359
        while (*e != '\0')
8360
          {
8361
            int m = 1;
8362
            /* Ignore newlines.  */
8363
            if (*e == '\n')
8364
              {
8365
                ++e;
8366
                continue;
8367
              }
8368
 
8369
            /* Check the arguments.  */
8370
            while (*e != ';')
8371
              {
8372
                const char *q;
8373
                int mp = 0;
8374
 
8375
                if (*e == '\0')
8376
                  {
8377
                  invalid_exclusion:
8378
                    fatal ("multilib exclusion '%s' is invalid",
8379
                           multilib_exclusions);
8380
                  }
8381
 
8382
                if (! m)
8383
                  {
8384
                    ++e;
8385
                    continue;
8386
                  }
8387
 
8388
                this_arg = e;
8389
 
8390
                while (*e != ' ' && *e != ';')
8391
                  {
8392
                    if (*e == '\0')
8393
                      goto invalid_exclusion;
8394
                    ++e;
8395
                  }
8396
 
8397
                q = p + 1;
8398
                while (*q != ';')
8399
                  {
8400
                    const char *arg;
8401
                    int len = e - this_arg;
8402
 
8403
                    if (*q == '\0')
8404
                      goto invalid_select;
8405
 
8406
                    arg = q;
8407
 
8408
                    while (*q != ' ' && *q != ';')
8409
                      {
8410
                        if (*q == '\0')
8411
                          goto invalid_select;
8412
                        ++q;
8413
                      }
8414
 
8415
                    if (! strncmp (arg, this_arg,
8416
                                   (len < q - arg) ? q - arg : len)
8417
                        || default_arg (this_arg, e - this_arg))
8418
                      {
8419
                        mp = 1;
8420
                        break;
8421
                      }
8422
 
8423
                    if (*q == ' ')
8424
                      ++q;
8425
                  }
8426
 
8427
                if (! mp)
8428
                  m = 0;
8429
 
8430
                if (*e == ' ')
8431
                  ++e;
8432
              }
8433
 
8434
            if (m)
8435
              {
8436
                skip = 1;
8437
                break;
8438
              }
8439
 
8440
            if (*e != '\0')
8441
              ++e;
8442
          }
8443
      }
8444
 
8445
      if (! skip)
8446
        {
8447
          /* If this is a duplicate, skip it.  */
8448
          skip = (last_path != 0
8449
                  && (unsigned int) (p - this_path) == last_path_len
8450
                  && ! strncmp (last_path, this_path, last_path_len));
8451
 
8452
          last_path = this_path;
8453
          last_path_len = p - this_path;
8454
        }
8455
 
8456
      /* If this directory requires any default arguments, we can skip
8457
         it.  We will already have printed a directory identical to
8458
         this one which does not require that default argument.  */
8459
      if (! skip)
8460
        {
8461
          const char *q;
8462
 
8463
          q = p + 1;
8464
          while (*q != ';')
8465
            {
8466
              const char *arg;
8467
 
8468
              if (*q == '\0')
8469
                goto invalid_select;
8470
 
8471
              if (*q == '!')
8472
                arg = NULL;
8473
              else
8474
                arg = q;
8475
 
8476
              while (*q != ' ' && *q != ';')
8477
                {
8478
                  if (*q == '\0')
8479
                    goto invalid_select;
8480
                  ++q;
8481
                }
8482
 
8483
              if (arg != NULL
8484
                  && default_arg (arg, q - arg))
8485
                {
8486
                  skip = 1;
8487
                  break;
8488
                }
8489
 
8490
              if (*q == ' ')
8491
                ++q;
8492
            }
8493
        }
8494
 
8495
      if (! skip)
8496
        {
8497
          const char *p1;
8498
 
8499
          for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8500
            putchar (*p1);
8501
          putchar (';');
8502
        }
8503
 
8504
      ++p;
8505
      while (*p != ';')
8506
        {
8507
          int use_arg;
8508
 
8509
          if (*p == '\0')
8510
            goto invalid_select;
8511
 
8512
          if (skip)
8513
            {
8514
              ++p;
8515
              continue;
8516
            }
8517
 
8518
          use_arg = *p != '!';
8519
 
8520
          if (use_arg)
8521
            putchar ('@');
8522
 
8523
          while (*p != ' ' && *p != ';')
8524
            {
8525
              if (*p == '\0')
8526
                goto invalid_select;
8527
              if (use_arg)
8528
                putchar (*p);
8529
              ++p;
8530
            }
8531
 
8532
          if (*p == ' ')
8533
            ++p;
8534
        }
8535
 
8536
      if (! skip)
8537
        {
8538
          /* If there are extra options, print them now.  */
8539
          if (multilib_extra && *multilib_extra)
8540
            {
8541
              int print_at = TRUE;
8542
              const char *q;
8543
 
8544
              for (q = multilib_extra; *q != '\0'; q++)
8545
                {
8546
                  if (*q == ' ')
8547
                    print_at = TRUE;
8548
                  else
8549
                    {
8550
                      if (print_at)
8551
                        putchar ('@');
8552
                      putchar (*q);
8553
                      print_at = FALSE;
8554
                    }
8555
                }
8556
            }
8557
 
8558
          putchar ('\n');
8559
        }
8560
 
8561
      ++p;
8562
    }
8563
}
8564
 
8565
/* getenv built-in spec function.
8566
 
8567
   Returns the value of the environment variable given by its first
8568
   argument, concatenated with the second argument.  If the
8569
   environment variable is not defined, a fatal error is issued.  */
8570
 
8571
static const char *
8572
getenv_spec_function (int argc, const char **argv)
8573
{
8574
  char *value;
8575
  char *result;
8576
  char *ptr;
8577
  size_t len;
8578
 
8579
  if (argc != 2)
8580
    return NULL;
8581
 
8582
  value = getenv (argv[0]);
8583
  if (!value)
8584
    fatal ("environment variable \"%s\" not defined", argv[0]);
8585
 
8586
  /* We have to escape every character of the environment variable so
8587
     they are not interpreted as active spec characters.  A
8588
     particularly painful case is when we are reading a variable
8589
     holding a windows path complete with \ separators.  */
8590
  len = strlen (value) * 2 + strlen (argv[1]) + 1;
8591
  result = XNEWVAR (char, len);
8592
  for (ptr = result; *value; ptr += 2)
8593
    {
8594
      ptr[0] = '\\';
8595
      ptr[1] = *value++;
8596
    }
8597
 
8598
  strcpy (ptr, argv[1]);
8599
 
8600
  return result;
8601
}
8602
 
8603
/* if-exists built-in spec function.
8604
 
8605
   Checks to see if the file specified by the absolute pathname in
8606
   ARGS exists.  Returns that pathname if found.
8607
 
8608
   The usual use for this function is to check for a library file
8609
   (whose name has been expanded with %s).  */
8610
 
8611
static const char *
8612
if_exists_spec_function (int argc, const char **argv)
8613
{
8614
  /* Must have only one argument.  */
8615
  if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8616
    return argv[0];
8617
 
8618
  return NULL;
8619
}
8620
 
8621
/* if-exists-else built-in spec function.
8622
 
8623
   This is like if-exists, but takes an additional argument which
8624
   is returned if the first argument does not exist.  */
8625
 
8626
static const char *
8627
if_exists_else_spec_function (int argc, const char **argv)
8628
{
8629
  /* Must have exactly two arguments.  */
8630
  if (argc != 2)
8631
    return NULL;
8632
 
8633
  if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8634
    return argv[0];
8635
 
8636
  return argv[1];
8637
}
8638
 
8639
/* replace-outfile built-in spec function.
8640
 
8641
   This looks for the first argument in the outfiles array's name and
8642
   replaces it with the second argument.  */
8643
 
8644
static const char *
8645
replace_outfile_spec_function (int argc, const char **argv)
8646
{
8647
  int i;
8648
  /* Must have exactly two arguments.  */
8649
  if (argc != 2)
8650
    abort ();
8651
 
8652
  for (i = 0; i < n_infiles; i++)
8653
    {
8654
      if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8655
        outfiles[i] = xstrdup (argv[1]);
8656
    }
8657
  return NULL;
8658
}
8659
 
8660
/* Given two version numbers, compares the two numbers.
8661
   A version number must match the regular expression
8662
   ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8663
*/
8664
static int
8665
compare_version_strings (const char *v1, const char *v2)
8666
{
8667
  int rresult;
8668
  regex_t r;
8669
 
8670
  if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8671
               REG_EXTENDED | REG_NOSUB) != 0)
8672
    abort ();
8673
  rresult = regexec (&r, v1, 0, NULL, 0);
8674
  if (rresult == REG_NOMATCH)
8675
    fatal ("invalid version number `%s'", v1);
8676
  else if (rresult != 0)
8677
    abort ();
8678
  rresult = regexec (&r, v2, 0, NULL, 0);
8679
  if (rresult == REG_NOMATCH)
8680
    fatal ("invalid version number `%s'", v2);
8681
  else if (rresult != 0)
8682
    abort ();
8683
 
8684
  return strverscmp (v1, v2);
8685
}
8686
 
8687
 
8688
/* version_compare built-in spec function.
8689
 
8690
   This takes an argument of the following form:
8691
 
8692
   <comparison-op> <arg1> [<arg2>] <switch> <result>
8693
 
8694
   and produces "result" if the comparison evaluates to true,
8695
   and nothing if it doesn't.
8696
 
8697
   The supported <comparison-op> values are:
8698
 
8699
   >=  true if switch is a later (or same) version than arg1
8700
   !>  opposite of >=
8701
   <   true if switch is an earlier version than arg1
8702
   !<  opposite of <
8703
   ><  true if switch is arg1 or later, and earlier than arg2
8704
   <>  true if switch is earlier than arg1 or is arg2 or later
8705
 
8706
   If the switch is not present, the condition is false unless
8707
   the first character of the <comparison-op> is '!'.
8708
 
8709
   For example,
8710
   %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8711
   adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
8712
 
8713
static const char *
8714
version_compare_spec_function (int argc, const char **argv)
8715
{
8716
  int comp1, comp2;
8717
  size_t switch_len;
8718
  const char *switch_value = NULL;
8719
  int nargs = 1, i;
8720
  bool result;
8721
 
8722
  if (argc < 3)
8723
    fatal ("too few arguments to %%:version-compare");
8724
  if (argv[0][0] == '\0')
8725
    abort ();
8726
  if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8727
    nargs = 2;
8728
  if (argc != nargs + 3)
8729
    fatal ("too many arguments to %%:version-compare");
8730
 
8731
  switch_len = strlen (argv[nargs + 1]);
8732
  for (i = 0; i < n_switches; i++)
8733
    if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8734
        && check_live_switch (i, switch_len))
8735
      switch_value = switches[i].part1 + switch_len;
8736
 
8737
  if (switch_value == NULL)
8738
    comp1 = comp2 = -1;
8739
  else
8740
    {
8741
      comp1 = compare_version_strings (switch_value, argv[1]);
8742
      if (nargs == 2)
8743
        comp2 = compare_version_strings (switch_value, argv[2]);
8744
      else
8745
        comp2 = -1;  /* This value unused.  */
8746
    }
8747
 
8748
  switch (argv[0][0] << 8 | argv[0][1])
8749
    {
8750
    case '>' << 8 | '=':
8751
      result = comp1 >= 0;
8752
      break;
8753
    case '!' << 8 | '<':
8754
      result = comp1 >= 0 || switch_value == NULL;
8755
      break;
8756
    case '<' << 8:
8757
      result = comp1 < 0;
8758
      break;
8759
    case '!' << 8 | '>':
8760
      result = comp1 < 0 || switch_value == NULL;
8761
      break;
8762
    case '>' << 8 | '<':
8763
      result = comp1 >= 0 && comp2 < 0;
8764
      break;
8765
    case '<' << 8 | '>':
8766
      result = comp1 < 0 || comp2 >= 0;
8767
      break;
8768
 
8769
    default:
8770
      fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
8771
    }
8772
  if (! result)
8773
    return NULL;
8774
 
8775
  return argv[nargs + 2];
8776
}
8777
 
8778
/* %:include builtin spec function.  This differs from %include in that it
8779
   can be nested inside a spec, and thus be conditionalized.  It takes
8780
   one argument, the filename, and looks for it in the startfile path.
8781
   The result is always NULL, i.e. an empty expansion.  */
8782
 
8783
static const char *
8784
include_spec_function (int argc, const char **argv)
8785
{
8786
  char *file;
8787
 
8788
  if (argc != 1)
8789
    abort ();
8790
 
8791
  file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8792
  read_specs (file ? file : argv[0], FALSE);
8793
 
8794
  return NULL;
8795
}
8796
 
8797
/* %:print-asm-header spec function.  Print a banner to say that the
8798
   following output is from the assembler.  */
8799
 
8800
static const char *
8801
print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8802
                                const char **argv ATTRIBUTE_UNUSED)
8803
{
8804
  printf (_("Assembler options\n=================\n\n"));
8805
  printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8806
  fflush (stdout);
8807
  return NULL;
8808
}
8809
 
8810
/* Compute a timestamp to initialize flag_random_seed.  */
8811
 
8812
static unsigned
8813
get_local_tick (void)
8814
{
8815
  unsigned ret = 0;
8816
 
8817
  /* Get some more or less random data.  */
8818
#ifdef HAVE_GETTIMEOFDAY
8819
  {
8820
    struct timeval tv;
8821
 
8822
    gettimeofday (&tv, NULL);
8823
    ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8824
  }
8825
#else
8826
  {
8827
    time_t now = time (NULL);
8828
 
8829
    if (now != (time_t)-1)
8830
      ret = (unsigned) now;
8831
  }
8832
#endif
8833
 
8834
  return ret;
8835
}
8836
 
8837
/* %:compare-debug-dump-opt spec function.  Save the last argument,
8838
   expected to be the last -fdump-final-insns option, or generate a
8839
   temporary.  */
8840
 
8841
static const char *
8842
compare_debug_dump_opt_spec_function (int arg,
8843
                                      const char **argv ATTRIBUTE_UNUSED)
8844
{
8845
  const char *ret;
8846
  char *name;
8847
  int which;
8848
  static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8849
 
8850
  if (arg != 0)
8851
    fatal ("too many arguments to %%:compare-debug-dump-opt");
8852
 
8853
  do_spec_2 ("%{fdump-final-insns=*:%*}");
8854
  do_spec_1 (" ", 0, NULL);
8855
 
8856
  if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8857
    {
8858
      if (!compare_debug)
8859
        return NULL;
8860
 
8861
      name = xstrdup (argv[argbuf_index - 1]);
8862
      ret = NULL;
8863
    }
8864
  else
8865
    {
8866
      const char *ext = NULL;
8867
 
8868
      if (argbuf_index > 0)
8869
        {
8870
          do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8871
          ext = ".gkd";
8872
        }
8873
      else if (!compare_debug)
8874
        return NULL;
8875
      else
8876
        do_spec_2 ("%g.gkd");
8877
 
8878
      do_spec_1 (" ", 0, NULL);
8879
 
8880
      gcc_assert (argbuf_index > 0);
8881
 
8882
      name = concat (argbuf[argbuf_index - 1], ext, NULL);
8883
 
8884
      ret = concat ("-fdump-final-insns=", name, NULL);
8885
    }
8886
 
8887
  which = compare_debug < 0;
8888
  debug_check_temp_file[which] = name;
8889
 
8890
  if (!which)
8891
    {
8892
      unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8893
 
8894
      sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8895
    }
8896
 
8897
  if (*random_seed)
8898
    ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8899
                  ret, NULL);
8900
 
8901
  if (which)
8902
    *random_seed = 0;
8903
 
8904
  return ret;
8905
}
8906
 
8907
static const char *debug_auxbase_opt;
8908
 
8909
/* %:compare-debug-self-opt spec function.  Expands to the options
8910
    that are to be passed in the second compilation of
8911
    compare-debug.  */
8912
 
8913
static const char *
8914
compare_debug_self_opt_spec_function (int arg,
8915
                                      const char **argv ATTRIBUTE_UNUSED)
8916
{
8917
  if (arg != 0)
8918
    fatal ("too many arguments to %%:compare-debug-self-opt");
8919
 
8920
  if (compare_debug >= 0)
8921
    return NULL;
8922
 
8923
  do_spec_2 ("%{c|S:%{o*:%*}}");
8924
  do_spec_1 (" ", 0, NULL);
8925
 
8926
  if (argbuf_index > 0)
8927
    debug_auxbase_opt = concat ("-auxbase-strip ",
8928
                                argbuf[argbuf_index - 1],
8929
                                NULL);
8930
  else
8931
    debug_auxbase_opt = NULL;
8932
 
8933
  return concat ("\
8934
%<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8935
%<fdump-final-insns=* -w -S -o %j \
8936
%{!fcompare-debug-second:-fcompare-debug-second} \
8937
", compare_debug_opt, NULL);
8938
}
8939
 
8940
/* %:compare-debug-auxbase-opt spec function.  Expands to the auxbase
8941
    options that are to be passed in the second compilation of
8942
    compare-debug.  It expects, as an argument, the basename of the
8943
    current input file name, with the .gk suffix appended to it.  */
8944
 
8945
static const char *
8946
compare_debug_auxbase_opt_spec_function (int arg,
8947
                                         const char **argv)
8948
{
8949
  char *name;
8950
  int len;
8951
 
8952
  if (arg == 0)
8953
    fatal ("too few arguments to %%:compare-debug-auxbase-opt");
8954
 
8955
  if (arg != 1)
8956
    fatal ("too many arguments to %%:compare-debug-auxbase-opt");
8957
 
8958
  if (compare_debug >= 0)
8959
    return NULL;
8960
 
8961
  len = strlen (argv[0]);
8962
  if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8963
    fatal ("argument to %%:compare-debug-auxbase-opt does not end in .gk");
8964
 
8965
  if (debug_auxbase_opt)
8966
    return debug_auxbase_opt;
8967
 
8968
#define OPT "-auxbase "
8969
 
8970
  len -= 3;
8971
  name = (char*) xmalloc (sizeof (OPT) + len);
8972
  memcpy (name, OPT, sizeof (OPT) - 1);
8973
  memcpy (name + sizeof (OPT) - 1, argv[0], len);
8974
  name[sizeof (OPT) - 1 + len] = '\0';
8975
 
8976
#undef OPT
8977
 
8978
  return name;
8979
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.