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