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