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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [gcc.c] - Blame information for rev 831

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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