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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [gcc.c] - Blame information for rev 856

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

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

powered by: WebSVN 2.1.0

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