26 27/* This program is the user interface to the C compiler and possibly to 28other compilers. It is used because compilation is a complicated procedure 29which involves running several programs and passing temporary files between 30them, forwarding the users switches to those programs selectively, 31and deleting the temporary files at the end. 32 33CC recognizes how to compile each input file by suffixes in the file names. 34Once it knows which kind of compilation to perform, the procedure for 35compilation is specified by a string called a "spec". */ 36 37/* A Short Introduction to Adding a Command-Line Option. 38 39 Before adding a command-line option, consider if it is really 40 necessary. Each additional command-line option adds complexity and 41 is difficult to remove in subsequent versions. 42 43 In the following, consider adding the command-line argument 44 `--bar'. 45 46 1. Each command-line option is specified in the specs file. The 47 notation is described below in the comment entitled "The Specs 48 Language". Read it. 49 50 2. In this file, add an entry to "option_map" equating the long 51 `--' argument version and any shorter, single letter version. Read 52 the comments in the declaration of "struct option_map" for an 53 explanation. Do not omit the first `-'. 54 55 3. Look in the "specs" file to determine which program or option 56 list should be given the argument, e.g., "cc1_options". Add the 57 appropriate syntax for the shorter option version to the 58 corresponding "const char *" entry in this file. Omit the first 59 `-' from the option. For example, use `-bar', rather than `--bar'. 60 61 4. If the argument takes an argument, e.g., `--baz argument1', 62 modify either DEFAULT_SWITCH_TAKES_ARG or 63 DEFAULT_WORD_SWITCH_TAKES_ARG in this file. Omit the first `-' 64 from `--baz'. 65 66 5. Document the option in this file's display_help(). If the 67 option is passed to a subprogram, modify its corresponding 68 function, e.g., cppinit.c:print_help() or toplev.c:display_help(), 69 instead. 70 71 6. Compile and test. Make sure that your new specs file is being 72 read. For example, use a debugger to investigate the value of 73 "specs_file" in main(). */ 74 75#include "config.h" 76#include "system.h" 77#include "coretypes.h" 78#include "multilib.h" /* before tm.h */ 79#include "tm.h" 80#include <signal.h> 81#if ! defined( SIGCHLD ) && defined( SIGCLD ) 82# define SIGCHLD SIGCLD 83#endif 84#include "obstack.h" 85#include "intl.h" 86#include "prefix.h" 87#include "gcc.h" 88#include "flags.h" 89 90#ifdef HAVE_SYS_RESOURCE_H 91#include <sys/resource.h> 92#endif 93#if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE 94extern int getrusage (int, struct rusage *); 95#endif 96 97/* By default there is no special suffix for target executables. */ 98/* FIXME: when autoconf is fixed, remove the host check - dj */ 99#if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX) 100#define HAVE_TARGET_EXECUTABLE_SUFFIX 101#endif 102 103/* By default there is no special suffix for host executables. */ 104#ifdef HOST_EXECUTABLE_SUFFIX 105#define HAVE_HOST_EXECUTABLE_SUFFIX 106#else 107#define HOST_EXECUTABLE_SUFFIX "" 108#endif 109 110/* By default, the suffix for target object files is ".o". */ 111#ifdef TARGET_OBJECT_SUFFIX 112#define HAVE_TARGET_OBJECT_SUFFIX 113#else 114#define TARGET_OBJECT_SUFFIX ".o" 115#endif 116 117static const char dir_separator_str[] = { DIR_SEPARATOR, 0 }; 118 119/* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */ 120#ifndef LIBRARY_PATH_ENV 121#define LIBRARY_PATH_ENV "LIBRARY_PATH" 122#endif 123 124#ifndef HAVE_KILL 125#define kill(p,s) raise(s) 126#endif 127 128/* If a stage of compilation returns an exit status >= 1, 129 compilation of that file ceases. */ 130 131#define MIN_FATAL_STATUS 1 132 133/* Flag set by cppspec.c to 1. */ 134int is_cpp_driver; 135 136/* Flag saying to pass the greatest exit code returned by a sub-process 137 to the calling program. */ 138static int pass_exit_codes; 139 140/* Definition of string containing the arguments given to configure. */ 141#include "configargs.h" 142 143/* Flag saying to print the directories gcc will search through looking for 144 programs, libraries, etc. */ 145 146static int print_search_dirs; 147 148/* Flag saying to print the full filename of this file 149 as found through our usual search mechanism. */ 150 151static const char *print_file_name = NULL; 152 153/* As print_file_name, but search for executable file. */ 154 155static const char *print_prog_name = NULL; 156 157/* Flag saying to print the relative path we'd use to 158 find libgcc.a given the current compiler flags. */ 159 160static int print_multi_directory; 161 162/* Flag saying to print the relative path we'd use to 163 find OS libraries given the current compiler flags. */ 164 165static int print_multi_os_directory; 166 167/* Flag saying to print the list of subdirectories and 168 compiler flags used to select them in a standard form. */ 169 170static int print_multi_lib; 171 172/* Flag saying to print the command line options understood by gcc and its 173 sub-processes. */ 174 175static int print_help_list; 176 177/* Flag indicating whether we should print the command and arguments */ 178 179static int verbose_flag; 180 181/* Flag indicating whether we should ONLY print the command and 182 arguments (like verbose_flag) without executing the command. 183 Displayed arguments are quoted so that the generated command 184 line is suitable for execution. This is intended for use in 185 shell scripts to capture the driver-generated command line. */ 186static int verbose_only_flag; 187 188/* Flag indicating to print target specific command line options. */ 189 190static int target_help_flag; 191 192/* Flag indicating whether we should report subprocess execution times 193 (if this is supported by the system - see pexecute.c). */ 194 195static int report_times; 196 197/* Nonzero means place this string before uses of /, so that include 198 and library files can be found in an alternate location. */ 199 200#ifdef TARGET_SYSTEM_ROOT 201static const char *target_system_root = TARGET_SYSTEM_ROOT; 202#else 203static const char *target_system_root = 0; 204#endif 205 206/* Nonzero means pass the updated target_system_root to the compiler. */ 207 208static int target_system_root_changed; 209 210/* Nonzero means append this string to target_system_root. */ 211 212static const char *target_sysroot_suffix = 0; 213 214/* Nonzero means append this string to target_system_root for headers. */ 215 216static const char *target_sysroot_hdrs_suffix = 0; 217 218/* Nonzero means write "temp" files in source directory 219 and use the source file's name in them, and don't delete them. */ 220 221static int save_temps_flag; 222 223/* Nonzero means use pipes to communicate between subprocesses. 224 Overridden by either of the above two flags. */ 225 226static int use_pipes; 227 228/* The compiler version. */ 229 230static const char *compiler_version; 231 232/* The target version specified with -V */ 233 234static const char *const spec_version = DEFAULT_TARGET_VERSION; 235 236/* The target machine specified with -b. */ 237 238static const char *spec_machine = DEFAULT_TARGET_MACHINE; 239 240/* Nonzero if cross-compiling. 241 When -b is used, the value comes from the `specs' file. */ 242 243#ifdef CROSS_COMPILE 244static const char *cross_compile = "1"; 245#else 246static const char *cross_compile = "0"; 247#endif 248 249#ifdef MODIFY_TARGET_NAME 250 251/* Information on how to alter the target name based on a command-line 252 switch. The only case we support now is simply appending or deleting a 253 string to or from the end of the first part of the configuration name. */ 254 255static const struct modify_target 256{ 257 const char *const sw; 258 const enum add_del {ADD, DELETE} add_del; 259 const char *const str; 260} 261modify_target[] = MODIFY_TARGET_NAME; 262#endif 263 264/* The number of errors that have occurred; the link phase will not be 265 run if this is nonzero. */ 266static int error_count = 0; 267 268/* Greatest exit code of sub-processes that has been encountered up to 269 now. */ 270static int greatest_status = 1; 271 272/* This is the obstack which we use to allocate many strings. */ 273 274static struct obstack obstack; 275 276/* This is the obstack to build an environment variable to pass to 277 collect2 that describes all of the relevant switches of what to 278 pass the compiler in building the list of pointers to constructors 279 and destructors. */ 280 281static struct obstack collect_obstack; 282 283/* These structs are used to collect resource usage information for 284 subprocesses. */ 285#ifdef HAVE_GETRUSAGE 286static struct rusage rus, prus; 287#endif 288 289/* Forward declaration for prototypes. */ 290struct path_prefix; 291 292static void init_spec (void); 293static void store_arg (const char *, int, int); 294static char *load_specs (const char *); 295static void read_specs (const char *, int); 296static void set_spec (const char *, const char *); 297static struct compiler *lookup_compiler (const char *, size_t, const char *); 298static char *build_search_list (struct path_prefix *, const char *, int); 299static void putenv_from_prefixes (struct path_prefix *, const char *); 300static int access_check (const char *, int); 301static char *find_a_file (struct path_prefix *, const char *, int, int); 302static void add_prefix (struct path_prefix *, const char *, const char *, 303 int, int, int *, int); 304static void add_sysrooted_prefix (struct path_prefix *, const char *, 305 const char *, int, int, int *, int); 306static void translate_options (int *, const char *const **); 307static char *skip_whitespace (char *); 308static void delete_if_ordinary (const char *); 309static void delete_temp_files (void); 310static void delete_failure_queue (void); 311static void clear_failure_queue (void); 312static int check_live_switch (int, int); 313static const char *handle_braces (const char *); 314static inline bool input_suffix_matches (const char *, const char *); 315static inline bool switch_matches (const char *, const char *, int); 316static inline void mark_matching_switches (const char *, const char *, int); 317static inline void process_marked_switches (void); 318static const char *process_brace_body (const char *, const char *, const char *, int, int); 319static const struct spec_function *lookup_spec_function (const char *); 320static const char *eval_spec_function (const char *, const char *); 321static const char *handle_spec_function (const char *); 322static char *save_string (const char *, int); 323static void set_collect_gcc_options (void); 324static int do_spec_1 (const char *, int, const char *); 325static int do_spec_2 (const char *); 326static void do_option_spec (const char *, const char *); 327static void do_self_spec (const char *); 328static const char *find_file (const char *); 329static int is_directory (const char *, const char *, int); 330static const char *validate_switches (const char *); 331static void validate_all_switches (void); 332static inline void validate_switches_from_spec (const char *); 333static void give_switch (int, int); 334static int used_arg (const char *, int); 335static int default_arg (const char *, int); 336static void set_multilib_dir (void); 337static void print_multilib_info (void); 338static void perror_with_name (const char *); 339static void pfatal_pexecute (const char *, const char *) ATTRIBUTE_NORETURN; 340static void notice (const char *, ...) ATTRIBUTE_PRINTF_1; 341static void display_help (void); 342static void add_preprocessor_option (const char *, int); 343static void add_assembler_option (const char *, int); 344static void add_linker_option (const char *, int); 345static void process_command (int, const char **); 346static int execute (void); 347static void alloc_args (void); 348static void clear_args (void); 349static void fatal_error (int); 350#ifdef ENABLE_SHARED_LIBGCC 351static void init_gcc_specs (struct obstack *, const char *, const char *, 352 const char *); 353#endif 354#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 355static const char *convert_filename (const char *, int, int); 356#endif 357 358static const char *if_exists_spec_function (int, const char **); 359static const char *if_exists_else_spec_function (int, const char **); 360 361/* The Specs Language 362 363Specs are strings containing lines, each of which (if not blank) 364is made up of a program name, and arguments separated by spaces. 365The program name must be exact and start from root, since no path 366is searched and it is unreliable to depend on the current working directory. 367Redirection of input or output is not supported; the subprograms must 368accept filenames saying what files to read and write. 369 370In addition, the specs can contain %-sequences to substitute variable text 371or for conditional text. Here is a table of all defined %-sequences. 372Note that spaces are not generated automatically around the results of 373expanding these sequences; therefore, you can concatenate them together 374or with constant text in a single argument. 375 376 %% substitute one % into the program name or argument. 377 %i substitute the name of the input file being processed. 378 %b substitute the basename of the input file being processed. 379 This is the substring up to (and not including) the last period 380 and not including the directory. 381 %B same as %b, but include the file suffix (text after the last period). 382 %gSUFFIX 383 substitute a file name that has suffix SUFFIX and is chosen 384 once per compilation, and mark the argument a la %d. To reduce 385 exposure to denial-of-service attacks, the file name is now 386 chosen in a way that is hard to predict even when previously 387 chosen file names are known. For example, `%g.s ... %g.o ... %g.s' 388 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches 389 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it 390 had been pre-processed. Previously, %g was simply substituted 391 with a file name chosen once per compilation, without regard 392 to any appended suffix (which was therefore treated just like 393 ordinary text), making such attacks more likely to succeed. 394 %|SUFFIX 395 like %g, but if -pipe is in effect, expands simply to "-". 396 %mSUFFIX 397 like %g, but if -pipe is in effect, expands to nothing. (We have both 398 %| and %m to accommodate differences between system assemblers; see 399 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.) 400 %uSUFFIX 401 like %g, but generates a new temporary file name even if %uSUFFIX 402 was already seen. 403 %USUFFIX 404 substitutes the last file name generated with %uSUFFIX, generating a 405 new one if there is no such last file name. In the absence of any 406 %uSUFFIX, this is just like %gSUFFIX, except they don't share 407 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s' 408 would involve the generation of two distinct file names, one 409 for each `%g.s' and another for each `%U.s'. Previously, %U was 410 simply substituted with a file name chosen for the previous %u, 411 without regard to any appended suffix. 412 %jSUFFIX 413 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is 414 writable, and if save-temps is off; otherwise, substitute the name 415 of a temporary file, just like %u. This temporary file is not 416 meant for communication between processes, but rather as a junk 417 disposal mechanism. 418 %.SUFFIX 419 substitutes .SUFFIX for the suffixes of a matched switch's args when 420 it is subsequently output with %*. SUFFIX is terminated by the next 421 space or %. 422 %d marks the argument containing or following the %d as a 423 temporary file name, so that that file will be deleted if CC exits 424 successfully. Unlike %g, this contributes no text to the argument. 425 %w marks the argument containing or following the %w as the 426 "output file" of this compilation. This puts the argument 427 into the sequence of arguments that %o will substitute later. 428 %V indicates that this compilation produces no "output file". 429 %W{...} 430 like %{...} but mark last argument supplied within 431 as a file to be deleted on failure. 432 %o substitutes the names of all the output files, with spaces 433 automatically placed around them. You should write spaces 434 around the %o as well or the results are undefined. 435 %o is for use in the specs for running the linker. 436 Input files whose names have no recognized suffix are not compiled 437 at all, but they are included among the output files, so they will 438 be linked. 439 %O substitutes the suffix for object files. Note that this is 440 handled specially when it immediately follows %g, %u, or %U 441 (with or without a suffix argument) because of the need for 442 those to form complete file names. The handling is such that 443 %O is treated exactly as if it had already been substituted, 444 except that %g, %u, and %U do not currently support additional 445 SUFFIX characters following %O as they would following, for 446 example, `.o'. 447 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot 448 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH 449 and -B options) as necessary. 450 %s current argument is the name of a library or startup file of some sort. 451 Search for that file in a standard list of directories 452 and substitute the full name found. 453 %eSTR Print STR as an error message. STR is terminated by a newline. 454 Use this when inconsistent options are detected. 455 %nSTR Print STR as a notice. STR is terminated by a newline. 456 %x{OPTION} Accumulate an option for %X. 457 %X Output the accumulated linker options specified by compilations. 458 %Y Output the accumulated assembler options specified by compilations. 459 %Z Output the accumulated preprocessor options specified by compilations. 460 %a process ASM_SPEC as a spec. 461 This allows config.h to specify part of the spec for running as. 462 %A process ASM_FINAL_SPEC as a spec. A capital A is actually 463 used here. This can be used to run a post-processor after the 464 assembler has done its job. 465 %D Dump out a -L option for each directory in startfile_prefixes. 466 If multilib_dir is set, extra entries are generated with it affixed. 467 %l process LINK_SPEC as a spec. 468 %L process LIB_SPEC as a spec. 469 %G process LIBGCC_SPEC as a spec. 470 %M output multilib_dir with directory separators replaced with "_"; 471 if multilib_dir is not set or is ".", output "". 472 %S process STARTFILE_SPEC as a spec. A capital S is actually used here. 473 %E process ENDFILE_SPEC as a spec. A capital E is actually used here. 474 %C process CPP_SPEC as a spec. 475 %1 process CC1_SPEC as a spec. 476 %2 process CC1PLUS_SPEC as a spec. 477 %* substitute the variable part of a matched option. (See below.) 478 Note that each comma in the substituted string is replaced by 479 a single space. 480 %<S remove all occurrences of -S from the command line. 481 Note - this command is position dependent. % commands in the 482 spec string before this one will see -S, % commands in the 483 spec string after this one will not. 484 %<S* remove all occurrences of all switches beginning with -S from the 485 command line. 486 %:function(args) 487 Call the named function FUNCTION, passing it ARGS. ARGS is 488 first processed as a nested spec string, then split into an 489 argument vector in the usual fashion. The function returns 490 a string which is processed as if it had appeared literally 491 as part of the current spec. 492 %{S} substitutes the -S switch, if that switch was given to CC. 493 If that switch was not specified, this substitutes nothing. 494 Here S is a metasyntactic variable. 495 %{S*} substitutes all the switches specified to CC whose names start 496 with -S. This is used for -o, -I, etc; switches that take 497 arguments. CC considers `-o foo' as being one switch whose 498 name starts with `o'. %{o*} would substitute this text, 499 including the space; thus, two arguments would be generated. 500 %{S*&T*} likewise, but preserve order of S and T options (the order 501 of S and T in the spec is not significant). Can be any number 502 of ampersand-separated variables; for each the wild card is 503 optional. Useful for CPP as %{D*&U*&A*}. 504 505 %{S:X} substitutes X, if the -S switch was given to CC. 506 %{!S:X} substitutes X, if the -S switch was NOT given to CC. 507 %{S*:X} substitutes X if one or more switches whose names start 508 with -S was given to CC. Normally X is substituted only 509 once, no matter how many such switches appeared. However, 510 if %* appears somewhere in X, then X will be substituted 511 once for each matching switch, with the %* replaced by the 512 part of that switch that matched the '*'. 513 %{.S:X} substitutes X, if processing a file with suffix S. 514 %{!.S:X} substitutes X, if NOT processing a file with suffix S. 515 516 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be 517 combined with !, ., and * as above binding stronger than the OR. 518 If %* appears in X, all of the alternatives must be starred, and 519 only the first matching alternative is substituted. 520 %{S:X; if S was given to CC, substitutes X; 521 T:Y; else if T was given to CC, substitutes Y; 522 :D} else substitutes D. There can be as many clauses as you need. 523 This may be combined with ., !, |, and * as above. 524 525 %(Spec) processes a specification defined in a specs file as *Spec: 526 %[Spec] as above, but put __ around -D arguments 527 528The conditional text X in a %{S:X} or similar construct may contain 529other nested % constructs or spaces, or even newlines. They are 530processed as usual, as described above. Trailing white space in X is 531ignored. White space may also appear anywhere on the left side of the 532colon in these constructs, except between . or * and the corresponding 533word. 534 535The -O, -f, -m, and -W switches are handled specifically in these 536constructs. If another value of -O or the negated form of a -f, -m, or 537-W switch is found later in the command line, the earlier switch 538value is ignored, except with {S*} where S is just one letter; this 539passes all matching options. 540 541The character | at the beginning of the predicate text is used to indicate 542that a command should be piped to the following command, but only if -pipe 543is specified. 544 545Note that it is built into CC which switches take arguments and which 546do not. You might think it would be useful to generalize this to 547allow each compiler's spec to say which switches take arguments. But 548this cannot be done in a consistent fashion. CC cannot even decide 549which input files have been specified without knowing which switches 550take arguments, and it must know which input files to compile in order 551to tell which compilers to run. 552 553CC also knows implicitly that arguments starting in `-l' are to be 554treated as compiler output files, and passed to the linker in their 555proper position among the other output files. */ 556 557/* Define the macros used for specs %a, %l, %L, %S, %C, %1. */ 558 559/* config.h can define ASM_SPEC to provide extra args to the assembler 560 or extra switch-translations. */ 561#ifndef ASM_SPEC 562#define ASM_SPEC "" 563#endif 564 565/* config.h can define ASM_FINAL_SPEC to run a post processor after 566 the assembler has run. */ 567#ifndef ASM_FINAL_SPEC 568#define ASM_FINAL_SPEC "" 569#endif 570 571/* config.h can define CPP_SPEC to provide extra args to the C preprocessor 572 or extra switch-translations. */ 573#ifndef CPP_SPEC 574#define CPP_SPEC "" 575#endif 576 577/* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus 578 or extra switch-translations. */ 579#ifndef CC1_SPEC 580#define CC1_SPEC "" 581#endif 582 583/* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus 584 or extra switch-translations. */ 585#ifndef CC1PLUS_SPEC 586#define CC1PLUS_SPEC "" 587#endif 588 589/* config.h can define LINK_SPEC to provide extra args to the linker 590 or extra switch-translations. */ 591#ifndef LINK_SPEC 592#define LINK_SPEC "" 593#endif 594 595/* config.h can define LIB_SPEC to override the default libraries. */ 596#ifndef LIB_SPEC 597#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}" 598#endif 599 600/* config.h can define LIBGCC_SPEC to override how and when libgcc.a is 601 included. */ 602#ifndef LIBGCC_SPEC 603#if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1) 604/* Have gcc do the search for libgcc.a. */ 605#define LIBGCC_SPEC "libgcc.a%s" 606#else 607#define LIBGCC_SPEC "-lgcc" 608#endif 609#endif 610 611/* config.h can define STARTFILE_SPEC to override the default crt0 files. */ 612#ifndef STARTFILE_SPEC 613#define STARTFILE_SPEC \ 614 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}" 615#endif 616 617/* config.h can define SWITCHES_NEED_SPACES to control which options 618 require spaces between the option and the argument. */ 619#ifndef SWITCHES_NEED_SPACES 620#define SWITCHES_NEED_SPACES "" 621#endif 622 623/* config.h can define ENDFILE_SPEC to override the default crtn files. */ 624#ifndef ENDFILE_SPEC 625#define ENDFILE_SPEC "" 626#endif 627 628#ifndef LINKER_NAME 629#define LINKER_NAME "collect2" 630#endif 631 632/* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g' 633 to the assembler. */ 634#ifndef ASM_DEBUG_SPEC 635# if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \ 636 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG) 637# define ASM_DEBUG_SPEC \ 638 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \ 639 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \ 640 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}") 641# else 642# if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG) 643# define ASM_DEBUG_SPEC "%{g*:--gstabs}" 644# endif 645# if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) 646# define ASM_DEBUG_SPEC "%{g*:--gdwarf2}" 647# endif 648# endif 649#endif 650#ifndef ASM_DEBUG_SPEC 651# define ASM_DEBUG_SPEC "" 652#endif 653 654/* Here is the spec for running the linker, after compiling all files. */ 655 656/* This is overridable by the target in case they need to specify the 657 -lgcc and -lc order specially, yet not require them to override all 658 of LINK_COMMAND_SPEC. */ 659#ifndef LINK_GCC_C_SEQUENCE_SPEC 660#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G" 661#endif 662 663#ifndef LINK_PIE_SPEC 664#ifdef HAVE_LD_PIE 665#define LINK_PIE_SPEC "%{pie:-pie} " 666#else 667#define LINK_PIE_SPEC "%{pie:} " 668#endif 669#endif 670 671/* -u* was put back because both BSD and SysV seem to support it. */ 672/* %{static:} simply prevents an error message if the target machine 673 doesn't handle -static. */ 674/* We want %{T*} after %{L*} and %D so that it can be used to specify linker 675 scripts which exist in user specified directories, or in standard 676 directories. */ 677#ifndef LINK_COMMAND_SPEC 678#define LINK_COMMAND_SPEC "\ 679%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\ 680 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\ 681 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\ 682 %{static:} %{L*} %(link_libgcc) %o %{fprofile-arcs|fprofile-generate:-lgcov}\ 683 %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\ 684 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}" 685#endif 686 687#ifndef LINK_LIBGCC_SPEC 688# ifdef LINK_LIBGCC_SPECIAL 689/* Don't generate -L options for startfile prefix list. */ 690# define LINK_LIBGCC_SPEC "" 691# else 692/* Do generate them. */ 693# define LINK_LIBGCC_SPEC "%D" 694# endif 695#endif 696 697#ifndef STARTFILE_PREFIX_SPEC 698# define STARTFILE_PREFIX_SPEC "" 699#endif 700 701#ifndef SYSROOT_SUFFIX_SPEC 702# define SYSROOT_SUFFIX_SPEC "" 703#endif 704 705#ifndef SYSROOT_HEADERS_SUFFIX_SPEC 706# define SYSROOT_HEADERS_SUFFIX_SPEC "" 707#endif 708 709static const char *asm_debug; 710static const char *cpp_spec = CPP_SPEC; 711static const char *cc1_spec = CC1_SPEC; 712static const char *cc1plus_spec = CC1PLUS_SPEC; 713static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC; 714static const char *asm_spec = ASM_SPEC; 715static const char *asm_final_spec = ASM_FINAL_SPEC; 716static const char *link_spec = LINK_SPEC; 717static const char *lib_spec = LIB_SPEC; 718static const char *libgcc_spec = LIBGCC_SPEC; 719static const char *endfile_spec = ENDFILE_SPEC; 720static const char *startfile_spec = STARTFILE_SPEC; 721static const char *switches_need_spaces = SWITCHES_NEED_SPACES; 722static const char *linker_name_spec = LINKER_NAME; 723static const char *link_command_spec = LINK_COMMAND_SPEC; 724static const char *link_libgcc_spec = LINK_LIBGCC_SPEC; 725static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC; 726static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC; 727static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC; 728 729/* Standard options to cpp, cc1, and as, to reduce duplication in specs. 730 There should be no need to override these in target dependent files, 731 but we need to copy them to the specs file so that newer versions 732 of the GCC driver can correctly drive older tool chains with the 733 appropriate -B options. */ 734 735/* When cpplib handles traditional preprocessing, get rid of this, and 736 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so 737 that we default the front end language better. */ 738static const char *trad_capable_cpp = 739"cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}"; 740 741/* We don't wrap .d files in %W{} since a missing .d file, and 742 therefore no dependency entry, confuses make into thinking a .o 743 file that happens to exist is up-to-date. */ 744static const char *cpp_unique_options = 745"%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\ 746 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\ 747 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\ 748 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\ 749 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\ 750 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\ 751 %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\ 752 %{E|M|MM:%W{o*}}"; 753 754/* This contains cpp options which are common with cc1_options and are passed 755 only when preprocessing only to avoid duplication. We pass the cc1 spec 756 options to the preprocessor so that it the cc1 spec may manipulate 757 options used to set target flags. Those special target flags settings may 758 in turn cause preprocessor symbols to be defined specially. */ 759static const char *cpp_options = 760"%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\ 761 %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\ 762 %{undef}"; 763 764/* This contains cpp options which are not passed when the preprocessor 765 output will be used by another program. */ 766static const char *cpp_debug_options = "%{d*}"; 767 768/* NB: This is shared amongst all front-ends. */ 769static const char *cc1_options = 770"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\ 771 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\ 772 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\ 773 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\ 774 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\ 775 %{Qn:-fno-ident} %{--help:--help}\ 776 %{--target-help:--target-help}\ 777 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\ 778 %{fsyntax-only:-o %j} %{-param*}"; 779 780static const char *asm_options = 781"%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}"; 782 783static const char *invoke_as = 784#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 785"%{!S:-o %|.s |\n as %(asm_options) %|.s %A }"; 786#else 787"%{!S:-o %|.s |\n as %(asm_options) %m.s %A }"; 788#endif 789 790/* Some compilers have limits on line lengths, and the multilib_select 791 and/or multilib_matches strings can be very long, so we build them at 792 run time. */ 793static struct obstack multilib_obstack; 794static const char *multilib_select; 795static const char *multilib_matches; 796static const char *multilib_defaults; 797static const char *multilib_exclusions; 798 799/* Check whether a particular argument is a default argument. */ 800 801#ifndef MULTILIB_DEFAULTS 802#define MULTILIB_DEFAULTS { "" } 803#endif 804 805static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS; 806 807#ifndef DRIVER_SELF_SPECS 808#define DRIVER_SELF_SPECS "" 809#endif 810 811static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS }; 812 813#ifndef OPTION_DEFAULT_SPECS 814#define OPTION_DEFAULT_SPECS { "", "" } 815#endif 816 817struct default_spec 818{ 819 const char *name; 820 const char *spec; 821}; 822 823static const struct default_spec 824 option_default_specs[] = { OPTION_DEFAULT_SPECS }; 825 826struct user_specs 827{ 828 struct user_specs *next; 829 const char *filename; 830}; 831 832static struct user_specs *user_specs_head, *user_specs_tail; 833 834#ifndef SWITCH_TAKES_ARG 835#define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR) 836#endif 837 838#ifndef WORD_SWITCH_TAKES_ARG 839#define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR) 840#endif 841 842#ifdef HAVE_TARGET_EXECUTABLE_SUFFIX 843/* This defines which switches stop a full compilation. */ 844#define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \ 845 ((CHAR) == 'c' || (CHAR) == 'S') 846 847#ifndef SWITCH_CURTAILS_COMPILATION 848#define SWITCH_CURTAILS_COMPILATION(CHAR) \ 849 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) 850#endif 851#endif 852 853/* Record the mapping from file suffixes for compilation specs. */ 854 855struct compiler 856{ 857 const char *suffix; /* Use this compiler for input files 858 whose names end in this suffix. */ 859 860 const char *spec; /* To use this compiler, run this spec. */ 861 862 const char *cpp_spec; /* If non-NULL, substitute this spec 863 for `%C', rather than the usual 864 cpp_spec. */ 865}; 866 867/* Pointer to a vector of `struct compiler' that gives the spec for 868 compiling a file, based on its suffix. 869 A file that does not end in any of these suffixes will be passed 870 unchanged to the loader and nothing else will be done to it. 871 872 An entry containing two 0s is used to terminate the vector. 873 874 If multiple entries match a file, the last matching one is used. */ 875 876static struct compiler *compilers; 877 878/* Number of entries in `compilers', not counting the null terminator. */ 879 880static int n_compilers; 881 882/* The default list of file name suffixes and their compilation specs. */ 883 884static const struct compiler default_compilers[] = 885{ 886 /* Add lists of suffixes of known languages here. If those languages 887 were not present when we built the driver, we will hit these copies 888 and be given a more meaningful error than "file not used since 889 linking is not done". */ 890 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0}, 891 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0}, 892 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0}, 893 {".CPP", "#C++", 0}, {".ii", "#C++", 0}, 894 {".ads", "#Ada", 0}, {".adb", "#Ada", 0}, 895 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0}, 896 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0}, 897 {".r", "#Ratfor", 0}, 898 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0}, 899 {".java", "#Java", 0}, {".class", "#Java", 0}, 900 {".zip", "#Java", 0}, {".jar", "#Java", 0}, 901 /* Next come the entries for C. */ 902 {".c", "@c", 0}, 903 {"@c", 904 /* cc1 has an integrated ISO C preprocessor. We should invoke the 905 external preprocessor if -save-temps is given. */ 906 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 907 %{!E:%{!M:%{!MM:\ 908 %{traditional|ftraditional:\ 909%eGNU C no longer supports -traditional without -E}\ 910 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 911 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\ 912 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \ 913 %(cc1_options)}\ 914 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\ 915 cc1 %(cpp_unique_options) %(cc1_options)}}}\ 916 %{!fsyntax-only:%(invoke_as)}}}}", 0}, 917 {"-", 918 "%{!E:%e-E or -x required when input is from standard input}\ 919 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0}, 920 {".h", "@c-header", 0}, 921 {"@c-header", 922 /* cc1 has an integrated ISO C preprocessor. We should invoke the 923 external preprocessor if -save-temps is given. */ 924 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 925 %{!E:%{!M:%{!MM:\ 926 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 927 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\ 928 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \ 929 %(cc1_options)\ 930 -o %g.s %{!o*:--output-pch=%i.gch}\ 931 %W{o*:--output-pch=%*}%V}\ 932 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\ 933 cc1 %(cpp_unique_options) %(cc1_options)\ 934 -o %g.s %{!o*:--output-pch=%i.gch}\ 935 %W{o*:--output-pch=%*}%V}}}}}}", 0}, 936 {".i", "@cpp-output", 0}, 937 {"@cpp-output", 938 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0}, 939 {".s", "@assembler", 0}, 940 {"@assembler", 941 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0}, 942 {".S", "@assembler-with-cpp", 0}, 943 {"@assembler-with-cpp", 944#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 945 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 946 %{E|M|MM:%(cpp_debug_options)}\ 947 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 948 as %(asm_debug) %(asm_options) %|.s %A }}}}" 949#else 950 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 951 %{E|M|MM:%(cpp_debug_options)}\ 952 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 953 as %(asm_debug) %(asm_options) %m.s %A }}}}" 954#endif 955 , 0}, 956 957#include "specs.h" 958 /* Mark end of table. */ 959 {0, 0, 0} 960}; 961 962/* Number of elements in default_compilers, not counting the terminator. */ 963 964static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1; 965 966/* A vector of options to give to the linker. 967 These options are accumulated by %x, 968 and substituted into the linker command with %X. */ 969static int n_linker_options; 970static char **linker_options; 971 972/* A vector of options to give to the assembler. 973 These options are accumulated by -Wa, 974 and substituted into the assembler command with %Y. */ 975static int n_assembler_options; 976static char **assembler_options; 977 978/* A vector of options to give to the preprocessor. 979 These options are accumulated by -Wp, 980 and substituted into the preprocessor command with %Z. */ 981static int n_preprocessor_options; 982static char **preprocessor_options; 983 984/* Define how to map long options into short ones. */ 985 986/* This structure describes one mapping. */ 987struct option_map 988{ 989 /* The long option's name. */ 990 const char *const name; 991 /* The equivalent short option. */ 992 const char *const equivalent; 993 /* Argument info. A string of flag chars; NULL equals no options. 994 a => argument required. 995 o => argument optional. 996 j => join argument to equivalent, making one word. 997 * => require other text after NAME as an argument. */ 998 const char *const arg_info; 999}; 1000 1001/* This is the table of mappings. Mappings are tried sequentially 1002 for each option encountered; the first one that matches, wins. */ 1003 1004static const struct option_map option_map[] = 1005 { 1006 {"--all-warnings", "-Wall", 0}, 1007 {"--ansi", "-ansi", 0}, 1008 {"--assemble", "-S", 0}, 1009 {"--assert", "-A", "a"}, 1010 {"--classpath", "-fclasspath=", "aj"}, 1011 {"--bootclasspath", "-fbootclasspath=", "aj"}, 1012 {"--CLASSPATH", "-fclasspath=", "aj"}, 1013 {"--comments", "-C", 0}, 1014 {"--comments-in-macros", "-CC", 0}, 1015 {"--compile", "-c", 0}, 1016 {"--debug", "-g", "oj"}, 1017 {"--define-macro", "-D", "aj"}, 1018 {"--dependencies", "-M", 0}, 1019 {"--dump", "-d", "a"}, 1020 {"--dumpbase", "-dumpbase", "a"}, 1021 {"--entry", "-e", 0}, 1022 {"--extra-warnings", "-W", 0}, 1023 {"--for-assembler", "-Wa", "a"}, 1024 {"--for-linker", "-Xlinker", "a"}, 1025 {"--force-link", "-u", "a"}, 1026 {"--imacros", "-imacros", "a"}, 1027 {"--include", "-include", "a"}, 1028 {"--include-barrier", "-I-", 0}, 1029 {"--include-directory", "-I", "aj"}, 1030 {"--include-directory-after", "-idirafter", "a"}, 1031 {"--include-prefix", "-iprefix", "a"}, 1032 {"--include-with-prefix", "-iwithprefix", "a"}, 1033 {"--include-with-prefix-before", "-iwithprefixbefore", "a"}, 1034 {"--include-with-prefix-after", "-iwithprefix", "a"}, 1035 {"--language", "-x", "a"}, 1036 {"--library-directory", "-L", "a"}, 1037 {"--machine", "-m", "aj"}, 1038 {"--machine-", "-m", "*j"}, 1039 {"--no-integrated-cpp", "-no-integrated-cpp", 0}, 1040 {"--no-line-commands", "-P", 0}, 1041 {"--no-precompiled-includes", "-noprecomp", 0}, 1042 {"--no-standard-includes", "-nostdinc", 0}, 1043 {"--no-standard-libraries", "-nostdlib", 0}, 1044 {"--no-warnings", "-w", 0}, 1045 {"--optimize", "-O", "oj"}, 1046 {"--output", "-o", "a"}, 1047 {"--output-class-directory", "-foutput-class-dir=", "ja"}, 1048 {"--param", "--param", "a"}, 1049 {"--pedantic", "-pedantic", 0}, 1050 {"--pedantic-errors", "-pedantic-errors", 0}, 1051 {"--pie", "-pie", 0}, 1052 {"--pipe", "-pipe", 0}, 1053 {"--prefix", "-B", "a"}, 1054 {"--preprocess", "-E", 0}, 1055 {"--print-search-dirs", "-print-search-dirs", 0}, 1056 {"--print-file-name", "-print-file-name=", "aj"}, 1057 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0}, 1058 {"--print-missing-file-dependencies", "-MG", 0}, 1059 {"--print-multi-lib", "-print-multi-lib", 0}, 1060 {"--print-multi-directory", "-print-multi-directory", 0}, 1061 {"--print-multi-os-directory", "-print-multi-os-directory", 0}, 1062 {"--print-prog-name", "-print-prog-name=", "aj"}, 1063 {"--profile", "-p", 0}, 1064 {"--profile-blocks", "-a", 0}, 1065 {"--quiet", "-q", 0}, 1066 {"--resource", "-fcompile-resource=", "aj"}, 1067 {"--save-temps", "-save-temps", 0}, 1068 {"--shared", "-shared", 0}, 1069 {"--silent", "-q", 0}, 1070 {"--specs", "-specs=", "aj"}, 1071 {"--static", "-static", 0}, 1072 {"--std", "-std=", "aj"}, 1073 {"--symbolic", "-symbolic", 0}, 1074 {"--time", "-time", 0}, 1075 {"--trace-includes", "-H", 0}, 1076 {"--traditional", "-traditional", 0}, 1077 {"--traditional-cpp", "-traditional-cpp", 0}, 1078 {"--trigraphs", "-trigraphs", 0}, 1079 {"--undefine-macro", "-U", "aj"}, 1080 {"--user-dependencies", "-MM", 0}, 1081 {"--verbose", "-v", 0}, 1082 {"--warn-", "-W", "*j"}, 1083 {"--write-dependencies", "-MD", 0}, 1084 {"--write-user-dependencies", "-MMD", 0}, 1085 {"--", "-f", "*j"} 1086 }; 1087 1088 1089#ifdef TARGET_OPTION_TRANSLATE_TABLE 1090static const struct { 1091 const char *const option_found; 1092 const char *const replacements; 1093} target_option_translations[] = 1094{ 1095 TARGET_OPTION_TRANSLATE_TABLE, 1096 { 0, 0 } 1097}; 1098#endif 1099 1100/* Translate the options described by *ARGCP and *ARGVP. 1101 Make a new vector and store it back in *ARGVP, 1102 and store its length in *ARGVC. */ 1103 1104static void 1105translate_options (int *argcp, const char *const **argvp) 1106{ 1107 int i; 1108 int argc = *argcp; 1109 const char *const *argv = *argvp; 1110 int newvsize = (argc + 2) * 2 * sizeof (const char *); 1111 const char **newv = xmalloc (newvsize); 1112 int newindex = 0; 1113 1114 i = 0; 1115 newv[newindex++] = argv[i++]; 1116 1117 while (i < argc) 1118 { 1119#ifdef TARGET_OPTION_TRANSLATE_TABLE 1120 int tott_idx; 1121 1122 for (tott_idx = 0; 1123 target_option_translations[tott_idx].option_found; 1124 tott_idx++) 1125 { 1126 if (strcmp (target_option_translations[tott_idx].option_found, 1127 argv[i]) == 0) 1128 { 1129 int spaces = 1; 1130 const char *sp; 1131 char *np; 1132 1133 for (sp = target_option_translations[tott_idx].replacements; 1134 *sp; sp++) 1135 { 1136 if (*sp == ' ') 1137 spaces ++; 1138 } 1139 1140 newvsize += spaces * sizeof (const char *); 1141 newv = xrealloc (newv, newvsize); 1142 1143 sp = target_option_translations[tott_idx].replacements; 1144 np = xstrdup (sp); 1145 1146 while (1) 1147 { 1148 while (*np == ' ') 1149 np++; 1150 if (*np == 0) 1151 break; 1152 newv[newindex++] = np; 1153 while (*np != ' ' && *np) 1154 np++; 1155 if (*np == 0) 1156 break; 1157 *np++ = 0; 1158 } 1159 1160 i ++; 1161 break; 1162 } 1163 } 1164 if (target_option_translations[tott_idx].option_found) 1165 continue; 1166#endif 1167 1168 /* Translate -- options. */ 1169 if (argv[i][0] == '-' && argv[i][1] == '-') 1170 { 1171 size_t j; 1172 /* Find a mapping that applies to this option. */ 1173 for (j = 0; j < ARRAY_SIZE (option_map); j++) 1174 { 1175 size_t optlen = strlen (option_map[j].name); 1176 size_t arglen = strlen (argv[i]); 1177 size_t complen = arglen > optlen ? optlen : arglen; 1178 const char *arginfo = option_map[j].arg_info; 1179 1180 if (arginfo == 0) 1181 arginfo = ""; 1182 1183 if (!strncmp (argv[i], option_map[j].name, complen)) 1184 { 1185 const char *arg = 0; 1186 1187 if (arglen < optlen) 1188 { 1189 size_t k; 1190 for (k = j + 1; k < ARRAY_SIZE (option_map); k++) 1191 if (strlen (option_map[k].name) >= arglen 1192 && !strncmp (argv[i], option_map[k].name, arglen)) 1193 { 1194 error ("ambiguous abbreviation %s", argv[i]); 1195 break; 1196 } 1197 1198 if (k != ARRAY_SIZE (option_map)) 1199 break; 1200 } 1201 1202 if (arglen > optlen) 1203 { 1204 /* If the option has an argument, accept that. */ 1205 if (argv[i][optlen] == '=') 1206 arg = argv[i] + optlen + 1; 1207 1208 /* If this mapping requires extra text at end of name, 1209 accept that as "argument". */ 1210 else if (strchr (arginfo, '*') != 0) 1211 arg = argv[i] + optlen; 1212 1213 /* Otherwise, extra text at end means mismatch. 1214 Try other mappings. */ 1215 else 1216 continue; 1217 } 1218 1219 else if (strchr (arginfo, '*') != 0) 1220 { 1221 error ("incomplete `%s' option", option_map[j].name); 1222 break; 1223 } 1224 1225 /* Handle arguments. */ 1226 if (strchr (arginfo, 'a') != 0) 1227 { 1228 if (arg == 0) 1229 { 1230 if (i + 1 == argc) 1231 { 1232 error ("missing argument to `%s' option", 1233 option_map[j].name); 1234 break; 1235 } 1236 1237 arg = argv[++i]; 1238 } 1239 } 1240 else if (strchr (arginfo, '*') != 0) 1241 ; 1242 else if (strchr (arginfo, 'o') == 0) 1243 { 1244 if (arg != 0) 1245 error ("extraneous argument to `%s' option", 1246 option_map[j].name); 1247 arg = 0; 1248 } 1249 1250 /* Store the translation as one argv elt or as two. */ 1251 if (arg != 0 && strchr (arginfo, 'j') != 0) 1252 newv[newindex++] = concat (option_map[j].equivalent, arg, 1253 NULL); 1254 else if (arg != 0) 1255 { 1256 newv[newindex++] = option_map[j].equivalent; 1257 newv[newindex++] = arg; 1258 } 1259 else 1260 newv[newindex++] = option_map[j].equivalent; 1261 1262 break; 1263 } 1264 } 1265 i++; 1266 } 1267 1268 /* Handle old-fashioned options--just copy them through, 1269 with their arguments. */ 1270 else if (argv[i][0] == '-') 1271 { 1272 const char *p = argv[i] + 1; 1273 int c = *p; 1274 int nskip = 1; 1275 1276 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 1277 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0); 1278 else if (WORD_SWITCH_TAKES_ARG (p)) 1279 nskip += WORD_SWITCH_TAKES_ARG (p); 1280 else if ((c == 'B' || c == 'b' || c == 'x') 1281 && p[1] == 0) 1282 nskip += 1; 1283 else if (! strcmp (p, "Xlinker")) 1284 nskip += 1; 1285 else if (! strcmp (p, "Xpreprocessor")) 1286 nskip += 1; 1287 else if (! strcmp (p, "Xassembler")) 1288 nskip += 1; 1289 1290 /* Watch out for an option at the end of the command line that 1291 is missing arguments, and avoid skipping past the end of the 1292 command line. */ 1293 if (nskip + i > argc) 1294 nskip = argc - i; 1295 1296 while (nskip > 0) 1297 { 1298 newv[newindex++] = argv[i++]; 1299 nskip--; 1300 } 1301 } 1302 else 1303 /* Ordinary operands, or +e options. */ 1304 newv[newindex++] = argv[i++]; 1305 } 1306 1307 newv[newindex] = 0; 1308 1309 *argvp = newv; 1310 *argcp = newindex; 1311} 1312 1313static char * 1314skip_whitespace (char *p) 1315{ 1316 while (1) 1317 { 1318 /* A fully-blank line is a delimiter in the SPEC file and shouldn't 1319 be considered whitespace. */ 1320 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n') 1321 return p + 1; 1322 else if (*p == '\n' || *p == ' ' || *p == '\t') 1323 p++; 1324 else if (*p == '#') 1325 { 1326 while (*p != '\n') 1327 p++; 1328 p++; 1329 } 1330 else 1331 break; 1332 } 1333 1334 return p; 1335} 1336/* Structures to keep track of prefixes to try when looking for files. */ 1337 1338struct prefix_list 1339{ 1340 const char *prefix; /* String to prepend to the path. */ 1341 struct prefix_list *next; /* Next in linked list. */ 1342 int require_machine_suffix; /* Don't use without machine_suffix. */ 1343 /* 2 means try both machine_suffix and just_machine_suffix. */ 1344 int *used_flag_ptr; /* 1 if a file was found with this prefix. */ 1345 int priority; /* Sort key - priority within list. */ 1346 int os_multilib; /* 1 if OS multilib scheme should be used, 1347 0 for GCC multilib scheme. */ 1348}; 1349 1350struct path_prefix 1351{ 1352 struct prefix_list *plist; /* List of prefixes to try */ 1353 int max_len; /* Max length of a prefix in PLIST */ 1354 const char *name; /* Name of this list (used in config stuff) */ 1355}; 1356 1357/* List of prefixes to try when looking for executables. */ 1358 1359static struct path_prefix exec_prefixes = { 0, 0, "exec" }; 1360 1361/* List of prefixes to try when looking for startup (crt0) files. */ 1362 1363static struct path_prefix startfile_prefixes = { 0, 0, "startfile" }; 1364 1365/* List of prefixes to try when looking for include files. */ 1366 1367static struct path_prefix include_prefixes = { 0, 0, "include" }; 1368 1369/* Suffix to attach to directories searched for commands. 1370 This looks like `MACHINE/VERSION/'. */ 1371 1372static const char *machine_suffix = 0; 1373 1374/* Suffix to attach to directories searched for commands. 1375 This is just `MACHINE/'. */ 1376 1377static const char *just_machine_suffix = 0; 1378 1379/* Adjusted value of GCC_EXEC_PREFIX envvar. */ 1380 1381static const char *gcc_exec_prefix; 1382 1383/* Adjusted value of standard_libexec_prefix. */ 1384 1385static const char *gcc_libexec_prefix; 1386 1387/* Default prefixes to attach to command names. */ 1388 1389#ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */ 1390#undef MD_EXEC_PREFIX 1391#undef MD_STARTFILE_PREFIX 1392#undef MD_STARTFILE_PREFIX_1 1393#endif 1394 1395/* If no prefixes defined, use the null string, which will disable them. */ 1396#ifndef MD_EXEC_PREFIX 1397#define MD_EXEC_PREFIX "" 1398#endif 1399#ifndef MD_STARTFILE_PREFIX 1400#define MD_STARTFILE_PREFIX "" 1401#endif 1402#ifndef MD_STARTFILE_PREFIX_1 1403#define MD_STARTFILE_PREFIX_1 "" 1404#endif 1405 1406static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX; 1407static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/"; 1408static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/"; 1409static const char *md_exec_prefix = MD_EXEC_PREFIX; 1410 1411static const char *md_startfile_prefix = MD_STARTFILE_PREFIX; 1412static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1; 1413static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; 1414static const char *const standard_startfile_prefix_1 = "/lib/"; 1415static const char *const standard_startfile_prefix_2 = "/usr/lib/"; 1416 1417static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX; 1418static const char *tooldir_prefix; 1419 1420#ifndef FREEBSD_NATIVE 1421static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX; 1422#endif /* not FREEBSD_NATIVE */ 1423 1424static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX; 1425 1426/* Subdirectory to use for locating libraries. Set by 1427 set_multilib_dir based on the compilation options. */ 1428 1429static const char *multilib_dir; 1430 1431/* Subdirectory to use for locating libraries in OS conventions. Set by 1432 set_multilib_dir based on the compilation options. */ 1433 1434static const char *multilib_os_dir; 1435 1436/* Structure to keep track of the specs that have been defined so far. 1437 These are accessed using %(specname) or %[specname] in a compiler 1438 or link spec. */ 1439 1440struct spec_list 1441{ 1442 /* The following 2 fields must be first */ 1443 /* to allow EXTRA_SPECS to be initialized */ 1444 const char *name; /* name of the spec. */ 1445 const char *ptr; /* available ptr if no static pointer */ 1446 1447 /* The following fields are not initialized */ 1448 /* by EXTRA_SPECS */ 1449 const char **ptr_spec; /* pointer to the spec itself. */ 1450 struct spec_list *next; /* Next spec in linked list. */ 1451 int name_len; /* length of the name */ 1452 int alloc_p; /* whether string was allocated */ 1453}; 1454 1455#define INIT_STATIC_SPEC(NAME,PTR) \ 1456{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 } 1457 1458/* List of statically defined specs. */ 1459static struct spec_list static_specs[] = 1460{ 1461 INIT_STATIC_SPEC ("asm", &asm_spec), 1462 INIT_STATIC_SPEC ("asm_debug", &asm_debug), 1463 INIT_STATIC_SPEC ("asm_final", &asm_final_spec), 1464 INIT_STATIC_SPEC ("asm_options", &asm_options), 1465 INIT_STATIC_SPEC ("invoke_as", &invoke_as), 1466 INIT_STATIC_SPEC ("cpp", &cpp_spec), 1467 INIT_STATIC_SPEC ("cpp_options", &cpp_options), 1468 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options), 1469 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options), 1470 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp), 1471 INIT_STATIC_SPEC ("cc1", &cc1_spec), 1472 INIT_STATIC_SPEC ("cc1_options", &cc1_options), 1473 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec), 1474 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec), 1475 INIT_STATIC_SPEC ("endfile", &endfile_spec), 1476 INIT_STATIC_SPEC ("link", &link_spec), 1477 INIT_STATIC_SPEC ("lib", &lib_spec), 1478 INIT_STATIC_SPEC ("libgcc", &libgcc_spec), 1479 INIT_STATIC_SPEC ("startfile", &startfile_spec), 1480 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces), 1481 INIT_STATIC_SPEC ("cross_compile", &cross_compile), 1482 INIT_STATIC_SPEC ("version", &compiler_version), 1483 INIT_STATIC_SPEC ("multilib", &multilib_select), 1484 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults), 1485 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra), 1486 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches), 1487 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions), 1488 INIT_STATIC_SPEC ("multilib_options", &multilib_options), 1489 INIT_STATIC_SPEC ("linker", &linker_name_spec), 1490 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec), 1491 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix), 1492 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix), 1493 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1), 1494 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec), 1495 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec), 1496 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec), 1497}; 1498 1499#ifdef EXTRA_SPECS /* additional specs needed */ 1500/* Structure to keep track of just the first two args of a spec_list. 1501 That is all that the EXTRA_SPECS macro gives us. */ 1502struct spec_list_1 1503{ 1504 const char *const name; 1505 const char *const ptr; 1506}; 1507 1508static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS }; 1509static struct spec_list *extra_specs = (struct spec_list *) 0; 1510#endif 1511 1512/* List of dynamically allocates specs that have been defined so far. */ 1513 1514static struct spec_list *specs = (struct spec_list *) 0; 1515 1516/* List of static spec functions. */ 1517 1518static const struct spec_function static_spec_functions[] = 1519{ 1520 { "if-exists", if_exists_spec_function }, 1521 { "if-exists-else", if_exists_else_spec_function }, 1522 { 0, 0 } 1523}; 1524 1525static int processing_spec_function; 1526 1527/* Add appropriate libgcc specs to OBSTACK, taking into account 1528 various permutations of -shared-libgcc, -shared, and such. */ 1529 1530#ifdef ENABLE_SHARED_LIBGCC 1531static void 1532init_gcc_specs (struct obstack *obstack, const char *shared_name, 1533 const char *static_name, const char *eh_name) 1534{ 1535 char *buf; 1536 1537 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, 1538 "}%{!static:%{!static-libgcc:", 1539#ifdef HAVE_LD_AS_NEEDED 1540 "%{!shared-libgcc:", static_name, 1541 " --as-needed ", shared_name, " --no-as-needed}" 1542 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name, 1543 "}", 1544#else 1545 "%{!shared:%{!shared-libgcc:", static_name, " ", 1546 eh_name, "}%{shared-libgcc:", shared_name, " ", 1547 static_name, "}}%{shared:", 1548#ifdef LINK_EH_SPEC 1549 "%{shared-libgcc:", shared_name, 1550 "}%{!shared-libgcc:", static_name, "}", 1551#else 1552 shared_name, 1553#endif 1554#endif 1555 "}}}", NULL); 1556 1557 obstack_grow (obstack, buf, strlen (buf)); 1558 free (buf); 1559} 1560#endif /* ENABLE_SHARED_LIBGCC */ 1561 1562/* Initialize the specs lookup routines. */ 1563 1564static void 1565init_spec (void) 1566{ 1567 struct spec_list *next = (struct spec_list *) 0; 1568 struct spec_list *sl = (struct spec_list *) 0; 1569 int i; 1570 1571 if (specs) 1572 return; /* Already initialized. */ 1573 1574 if (verbose_flag) 1575 notice ("Using built-in specs.\n"); 1576 1577#ifdef EXTRA_SPECS 1578 extra_specs = xcalloc (sizeof (struct spec_list), 1579 ARRAY_SIZE (extra_specs_1)); 1580 1581 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--) 1582 { 1583 sl = &extra_specs[i]; 1584 sl->name = extra_specs_1[i].name; 1585 sl->ptr = extra_specs_1[i].ptr; 1586 sl->next = next; 1587 sl->name_len = strlen (sl->name); 1588 sl->ptr_spec = &sl->ptr; 1589 next = sl; 1590 } 1591#endif 1592 1593 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes 1594 on ?: in file-scope variable initializations. */ 1595 asm_debug = ASM_DEBUG_SPEC; 1596 1597 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1598 { 1599 sl = &static_specs[i]; 1600 sl->next = next; 1601 next = sl; 1602 } 1603 1604#ifdef ENABLE_SHARED_LIBGCC 1605 /* ??? If neither -shared-libgcc nor --static-libgcc was 1606 seen, then we should be making an educated guess. Some proposed 1607 heuristics for ELF include: 1608 1609 (1) If "-Wl,--export-dynamic", then it's a fair bet that the 1610 program will be doing dynamic loading, which will likely 1611 need the shared libgcc. 1612 1613 (2) If "-ldl", then it's also a fair bet that we're doing 1614 dynamic loading. 1615 1616 (3) For each ET_DYN we're linking against (either through -lfoo 1617 or /some/path/foo.so), check to see whether it or one of 1618 its dependencies depends on a shared libgcc. 1619 1620 (4) If "-shared" 1621 1622 If the runtime is fixed to look for program headers instead 1623 of calling __register_frame_info at all, for each object, 1624 use the shared libgcc if any EH symbol referenced. 1625 1626 If crtstuff is fixed to not invoke __register_frame_info 1627 automatically, for each object, use the shared libgcc if 1628 any non-empty unwind section found. 1629 1630 Doing any of this probably requires invoking an external program to 1631 do the actual object file scanning. */ 1632 { 1633 const char *p = libgcc_spec; 1634 int in_sep = 1; 1635 1636 /* Transform the extant libgcc_spec into one that uses the shared libgcc 1637 when given the proper command line arguments. */ 1638 while (*p) 1639 { 1640 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0) 1641 { 1642 init_gcc_specs (&obstack, 1643#ifdef NO_SHARED_LIBGCC_MULTILIB 1644 "-lgcc_s" 1645#else 1646 "-lgcc_s%M" 1647#endif 1648#ifdef USE_LIBUNWIND_EXCEPTIONS 1649 " -lunwind" 1650#endif 1651 , 1652 "-lgcc", 1653 "-lgcc_eh" 1654#ifdef USE_LIBUNWIND_EXCEPTIONS 1655# ifdef HAVE_LD_STATIC_DYNAMIC 1656 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}" 1657# else 1658 " -lunwind" 1659# endif 1660#endif 1661 ); 1662 1663 p += 5; 1664 in_sep = 0; 1665 } 1666 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0) 1667 { 1668 /* Ug. We don't know shared library extensions. Hope that 1669 systems that use this form don't do shared libraries. */ 1670 init_gcc_specs (&obstack, 1671#ifdef NO_SHARED_LIBGCC_MULTILIB 1672 "-lgcc_s" 1673#else 1674 "-lgcc_s%M" 1675#endif 1676 , 1677 "libgcc.a%s", 1678 "libgcc_eh.a%s" 1679#ifdef USE_LIBUNWIND_EXCEPTIONS 1680 " -lunwind" 1681#endif 1682 ); 1683 p += 10; 1684 in_sep = 0; 1685 } 1686 else 1687 { 1688 obstack_1grow (&obstack, *p); 1689 in_sep = (*p == ' '); 1690 p += 1; 1691 } 1692 } 1693 1694 obstack_1grow (&obstack, '\0'); 1695 libgcc_spec = obstack_finish (&obstack); 1696 } 1697#endif 1698#ifdef USE_AS_TRADITIONAL_FORMAT 1699 /* Prepend "--traditional-format" to whatever asm_spec we had before. */ 1700 { 1701 static const char tf[] = "--traditional-format "; 1702 obstack_grow (&obstack, tf, sizeof(tf) - 1); 1703 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec)); 1704 asm_spec = obstack_finish (&obstack); 1705 } 1706#endif 1707#ifdef LINK_EH_SPEC 1708 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */ 1709 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1); 1710 obstack_grow0 (&obstack, link_spec, strlen (link_spec)); 1711 link_spec = obstack_finish (&obstack); 1712#endif 1713 1714 specs = sl; 1715} 1716 1717/* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is 1718 removed; If the spec starts with a + then SPEC is added to the end of the 1719 current spec. */ 1720 1721static void 1722set_spec (const char *name, const char *spec) 1723{ 1724 struct spec_list *sl; 1725 const char *old_spec; 1726 int name_len = strlen (name); 1727 int i; 1728 1729 /* If this is the first call, initialize the statically allocated specs. */ 1730 if (!specs) 1731 { 1732 struct spec_list *next = (struct spec_list *) 0; 1733 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1734 { 1735 sl = &static_specs[i]; 1736 sl->next = next; 1737 next = sl; 1738 } 1739 specs = sl; 1740 } 1741 1742 /* See if the spec already exists. */ 1743 for (sl = specs; sl; sl = sl->next) 1744 if (name_len == sl->name_len && !strcmp (sl->name, name)) 1745 break; 1746 1747 if (!sl) 1748 { 1749 /* Not found - make it. */ 1750 sl = xmalloc (sizeof (struct spec_list)); 1751 sl->name = xstrdup (name); 1752 sl->name_len = name_len; 1753 sl->ptr_spec = &sl->ptr; 1754 sl->alloc_p = 0; 1755 *(sl->ptr_spec) = ""; 1756 sl->next = specs; 1757 specs = sl; 1758 } 1759 1760 old_spec = *(sl->ptr_spec); 1761 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1])) 1762 ? concat (old_spec, spec + 1, NULL) 1763 : xstrdup (spec)); 1764 1765#ifdef DEBUG_SPECS 1766 if (verbose_flag) 1767 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec)); 1768#endif 1769 1770 /* Free the old spec. */ 1771 if (old_spec && sl->alloc_p) 1772 free ((void *) old_spec); 1773 1774 sl->alloc_p = 1; 1775} 1776 1777/* Accumulate a command (program name and args), and run it. */ 1778 1779/* Vector of pointers to arguments in the current line of specifications. */ 1780 1781static const char **argbuf; 1782 1783/* Number of elements allocated in argbuf. */ 1784 1785static int argbuf_length; 1786 1787/* Number of elements in argbuf currently in use (containing args). */ 1788 1789static int argbuf_index; 1790 1791/* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated 1792 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for 1793 it here. */ 1794 1795static struct temp_name { 1796 const char *suffix; /* suffix associated with the code. */ 1797 int length; /* strlen (suffix). */ 1798 int unique; /* Indicates whether %g or %u/%U was used. */ 1799 const char *filename; /* associated filename. */ 1800 int filename_length; /* strlen (filename). */ 1801 struct temp_name *next; 1802} *temp_names; 1803 1804/* Number of commands executed so far. */ 1805 1806static int execution_count; 1807 1808/* Number of commands that exited with a signal. */ 1809 1810static int signal_count; 1811 1812/* Name with which this program was invoked. */ 1813 1814static const char *programname; 1815 1816/* Allocate the argument vector. */ 1817 1818static void 1819alloc_args (void) 1820{ 1821 argbuf_length = 10; 1822 argbuf = xmalloc (argbuf_length * sizeof (const char *)); 1823} 1824 1825/* Clear out the vector of arguments (after a command is executed). */ 1826 1827static void 1828clear_args (void) 1829{ 1830 argbuf_index = 0; 1831} 1832 1833/* Add one argument to the vector at the end. 1834 This is done when a space is seen or at the end of the line. 1835 If DELETE_ALWAYS is nonzero, the arg is a filename 1836 and the file should be deleted eventually. 1837 If DELETE_FAILURE is nonzero, the arg is a filename 1838 and the file should be deleted if this compilation fails. */ 1839 1840static void 1841store_arg (const char *arg, int delete_always, int delete_failure) 1842{ 1843 if (argbuf_index + 1 == argbuf_length) 1844 argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *)); 1845 1846 argbuf[argbuf_index++] = arg; 1847 argbuf[argbuf_index] = 0; 1848 1849 if (delete_always || delete_failure) 1850 record_temp_file (arg, delete_always, delete_failure); 1851} 1852 1853/* Load specs from a file name named FILENAME, replacing occurrences of 1854 various different types of line-endings, \r\n, \n\r and just \r, with 1855 a single \n. */ 1856 1857static char * 1858load_specs (const char *filename) 1859{ 1860 int desc; 1861 int readlen; 1862 struct stat statbuf; 1863 char *buffer; 1864 char *buffer_p; 1865 char *specs; 1866 char *specs_p; 1867 1868 if (verbose_flag) 1869 notice ("Reading specs from %s\n", filename); 1870 1871 /* Open and stat the file. */ 1872 desc = open (filename, O_RDONLY, 0); 1873 if (desc < 0) 1874 pfatal_with_name (filename); 1875 if (stat (filename, &statbuf) < 0) 1876 pfatal_with_name (filename); 1877 1878 /* Read contents of file into BUFFER. */ 1879 buffer = xmalloc ((unsigned) statbuf.st_size + 1); 1880 readlen = read (desc, buffer, (unsigned) statbuf.st_size); 1881 if (readlen < 0) 1882 pfatal_with_name (filename); 1883 buffer[readlen] = 0; 1884 close (desc); 1885 1886 specs = xmalloc (readlen + 1); 1887 specs_p = specs; 1888 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++) 1889 { 1890 int skip = 0; 1891 char c = *buffer_p; 1892 if (c == '\r') 1893 { 1894 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */ 1895 skip = 1; 1896 else if (*(buffer_p + 1) == '\n') /* \r\n */ 1897 skip = 1; 1898 else /* \r */ 1899 c = '\n'; 1900 } 1901 if (! skip) 1902 *specs_p++ = c; 1903 } 1904 *specs_p = '\0'; 1905 1906 free (buffer); 1907 return (specs); 1908} 1909 1910/* Read compilation specs from a file named FILENAME, 1911 replacing the default ones. 1912 1913 A suffix which starts with `*' is a definition for 1914 one of the machine-specific sub-specs. The "suffix" should be 1915 *asm, *cc1, *cpp, *link, *startfile, etc. 1916 The corresponding spec is stored in asm_spec, etc., 1917 rather than in the `compilers' vector. 1918 1919 Anything invalid in the file is a fatal error. */ 1920 1921static void 1922read_specs (const char *filename, int main_p) 1923{ 1924 char *buffer; 1925 char *p; 1926 1927 buffer = load_specs (filename); 1928 1929 /* Scan BUFFER for specs, putting them in the vector. */ 1930 p = buffer; 1931 while (1) 1932 { 1933 char *suffix; 1934 char *spec; 1935 char *in, *out, *p1, *p2, *p3; 1936 1937 /* Advance P in BUFFER to the next nonblank nocomment line. */ 1938 p = skip_whitespace (p); 1939 if (*p == 0) 1940 break; 1941 1942 /* Is this a special command that starts with '%'? */ 1943 /* Don't allow this for the main specs file, since it would 1944 encourage people to overwrite it. */ 1945 if (*p == '%' && !main_p) 1946 { 1947 p1 = p; 1948 while (*p && *p != '\n') 1949 p++; 1950 1951 /* Skip '\n'. */ 1952 p++; 1953 1954 if (!strncmp (p1, "%include", sizeof ("%include") - 1) 1955 && (p1[sizeof "%include" - 1] == ' ' 1956 || p1[sizeof "%include" - 1] == '\t')) 1957 { 1958 char *new_filename; 1959 1960 p1 += sizeof ("%include"); 1961 while (*p1 == ' ' || *p1 == '\t') 1962 p1++; 1963 1964 if (*p1++ != '<' || p[-2] != '>') 1965 fatal ("specs %%include syntax malformed after %ld characters", 1966 (long) (p1 - buffer + 1)); 1967 1968 p[-2] = '\0'; 1969 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1970 read_specs (new_filename ? new_filename : p1, FALSE); 1971 continue; 1972 } 1973 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1) 1974 && (p1[sizeof "%include_noerr" - 1] == ' ' 1975 || p1[sizeof "%include_noerr" - 1] == '\t')) 1976 { 1977 char *new_filename; 1978 1979 p1 += sizeof "%include_noerr"; 1980 while (*p1 == ' ' || *p1 == '\t') 1981 p1++; 1982 1983 if (*p1++ != '<' || p[-2] != '>') 1984 fatal ("specs %%include syntax malformed after %ld characters", 1985 (long) (p1 - buffer + 1)); 1986 1987 p[-2] = '\0'; 1988 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1989 if (new_filename) 1990 read_specs (new_filename, FALSE); 1991 else if (verbose_flag) 1992 notice ("could not find specs file %s\n", p1); 1993 continue; 1994 } 1995 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1) 1996 && (p1[sizeof "%rename" - 1] == ' ' 1997 || p1[sizeof "%rename" - 1] == '\t')) 1998 { 1999 int name_len; 2000 struct spec_list *sl; 2001 struct spec_list *newsl; 2002 2003 /* Get original name. */ 2004 p1 += sizeof "%rename"; 2005 while (*p1 == ' ' || *p1 == '\t') 2006 p1++; 2007 2008 if (! ISALPHA ((unsigned char) *p1)) 2009 fatal ("specs %%rename syntax malformed after %ld characters", 2010 (long) (p1 - buffer)); 2011 2012 p2 = p1; 2013 while (*p2 && !ISSPACE ((unsigned char) *p2)) 2014 p2++; 2015 2016 if (*p2 != ' ' && *p2 != '\t') 2017 fatal ("specs %%rename syntax malformed after %ld characters", 2018 (long) (p2 - buffer)); 2019 2020 name_len = p2 - p1; 2021 *p2++ = '\0'; 2022 while (*p2 == ' ' || *p2 == '\t') 2023 p2++; 2024 2025 if (! ISALPHA ((unsigned char) *p2)) 2026 fatal ("specs %%rename syntax malformed after %ld characters", 2027 (long) (p2 - buffer)); 2028 2029 /* Get new spec name. */ 2030 p3 = p2; 2031 while (*p3 && !ISSPACE ((unsigned char) *p3)) 2032 p3++; 2033 2034 if (p3 != p - 1) 2035 fatal ("specs %%rename syntax malformed after %ld characters", 2036 (long) (p3 - buffer)); 2037 *p3 = '\0'; 2038 2039 for (sl = specs; sl; sl = sl->next) 2040 if (name_len == sl->name_len && !strcmp (sl->name, p1)) 2041 break; 2042 2043 if (!sl) 2044 fatal ("specs %s spec was not found to be renamed", p1); 2045 2046 if (strcmp (p1, p2) == 0) 2047 continue; 2048 2049 for (newsl = specs; newsl; newsl = newsl->next) 2050 if (strcmp (newsl->name, p2) == 0) 2051 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'", 2052 filename, p1, p2); 2053 2054 if (verbose_flag) 2055 { 2056 notice ("rename spec %s to %s\n", p1, p2); 2057#ifdef DEBUG_SPECS 2058 notice ("spec is '%s'\n\n", *(sl->ptr_spec)); 2059#endif 2060 } 2061 2062 set_spec (p2, *(sl->ptr_spec)); 2063 if (sl->alloc_p) 2064 free ((void *) *(sl->ptr_spec)); 2065 2066 *(sl->ptr_spec) = ""; 2067 sl->alloc_p = 0; 2068 continue; 2069 } 2070 else 2071 fatal ("specs unknown %% command after %ld characters", 2072 (long) (p1 - buffer)); 2073 } 2074 2075 /* Find the colon that should end the suffix. */ 2076 p1 = p; 2077 while (*p1 && *p1 != ':' && *p1 != '\n') 2078 p1++; 2079 2080 /* The colon shouldn't be missing. */ 2081 if (*p1 != ':') 2082 fatal ("specs file malformed after %ld characters", 2083 (long) (p1 - buffer)); 2084 2085 /* Skip back over trailing whitespace. */ 2086 p2 = p1; 2087 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) 2088 p2--; 2089 2090 /* Copy the suffix to a string. */ 2091 suffix = save_string (p, p2 - p); 2092 /* Find the next line. */ 2093 p = skip_whitespace (p1 + 1); 2094 if (p[1] == 0) 2095 fatal ("specs file malformed after %ld characters", 2096 (long) (p - buffer)); 2097 2098 p1 = p; 2099 /* Find next blank line or end of string. */ 2100 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0'))) 2101 p1++; 2102 2103 /* Specs end at the blank line and do not include the newline. */ 2104 spec = save_string (p, p1 - p); 2105 p = p1; 2106 2107 /* Delete backslash-newline sequences from the spec. */ 2108 in = spec; 2109 out = spec; 2110 while (*in != 0) 2111 { 2112 if (in[0] == '\\' && in[1] == '\n') 2113 in += 2; 2114 else if (in[0] == '#') 2115 while (*in && *in != '\n') 2116 in++; 2117 2118 else 2119 *out++ = *in++; 2120 } 2121 *out = 0; 2122 2123 if (suffix[0] == '*') 2124 { 2125 if (! strcmp (suffix, "*link_command")) 2126 link_command_spec = spec; 2127 else 2128 set_spec (suffix + 1, spec); 2129 } 2130 else 2131 { 2132 /* Add this pair to the vector. */ 2133 compilers 2134 = xrealloc (compilers, 2135 (n_compilers + 2) * sizeof (struct compiler)); 2136 2137 compilers[n_compilers].suffix = suffix; 2138 compilers[n_compilers].spec = spec; 2139 n_compilers++; 2140 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]); 2141 } 2142 2143 if (*suffix == 0) 2144 link_command_spec = spec; 2145 } 2146 2147 if (link_command_spec == 0) 2148 fatal ("spec file has no spec for linking"); 2149} 2150 2151/* Record the names of temporary files we tell compilers to write, 2152 and delete them at the end of the run. */ 2153 2154/* This is the common prefix we use to make temp file names. 2155 It is chosen once for each run of this program. 2156 It is substituted into a spec by %g or %j. 2157 Thus, all temp file names contain this prefix. 2158 In practice, all temp file names start with this prefix. 2159 2160 This prefix comes from the envvar TMPDIR if it is defined; 2161 otherwise, from the P_tmpdir macro if that is defined; 2162 otherwise, in /usr/tmp or /tmp; 2163 or finally the current directory if all else fails. */ 2164 2165static const char *temp_filename; 2166 2167/* Length of the prefix. */ 2168 2169static int temp_filename_length; 2170 2171/* Define the list of temporary files to delete. */ 2172 2173struct temp_file 2174{ 2175 const char *name; 2176 struct temp_file *next; 2177}; 2178 2179/* Queue of files to delete on success or failure of compilation. */ 2180static struct temp_file *always_delete_queue; 2181/* Queue of files to delete on failure of compilation. */ 2182static struct temp_file *failure_delete_queue; 2183 2184/* Record FILENAME as a file to be deleted automatically. 2185 ALWAYS_DELETE nonzero means delete it if all compilation succeeds; 2186 otherwise delete it in any case. 2187 FAIL_DELETE nonzero means delete it if a compilation step fails; 2188 otherwise delete it in any case. */ 2189 2190void 2191record_temp_file (const char *filename, int always_delete, int fail_delete) 2192{ 2193 char *const name = xstrdup (filename); 2194 2195 if (always_delete) 2196 { 2197 struct temp_file *temp; 2198 for (temp = always_delete_queue; temp; temp = temp->next) 2199 if (! strcmp (name, temp->name)) 2200 goto already1; 2201 2202 temp = xmalloc (sizeof (struct temp_file)); 2203 temp->next = always_delete_queue; 2204 temp->name = name; 2205 always_delete_queue = temp; 2206 2207 already1:; 2208 } 2209 2210 if (fail_delete) 2211 { 2212 struct temp_file *temp; 2213 for (temp = failure_delete_queue; temp; temp = temp->next) 2214 if (! strcmp (name, temp->name)) 2215 goto already2; 2216 2217 temp = xmalloc (sizeof (struct temp_file)); 2218 temp->next = failure_delete_queue; 2219 temp->name = name; 2220 failure_delete_queue = temp; 2221 2222 already2:; 2223 } 2224} 2225 2226/* Delete all the temporary files whose names we previously recorded. */ 2227 2228static void 2229delete_if_ordinary (const char *name) 2230{ 2231 struct stat st; 2232#ifdef DEBUG 2233 int i, c; 2234 2235 printf ("Delete %s? (y or n) ", name); 2236 fflush (stdout); 2237 i = getchar (); 2238 if (i != '\n') 2239 while ((c = getchar ()) != '\n' && c != EOF) 2240 ; 2241 2242 if (i == 'y' || i == 'Y') 2243#endif /* DEBUG */ 2244 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode)) 2245 if (unlink (name) < 0) 2246 if (verbose_flag) 2247 perror_with_name (name); 2248} 2249 2250static void 2251delete_temp_files (void) 2252{ 2253 struct temp_file *temp; 2254 2255 for (temp = always_delete_queue; temp; temp = temp->next) 2256 delete_if_ordinary (temp->name); 2257 always_delete_queue = 0; 2258} 2259 2260/* Delete all the files to be deleted on error. */ 2261 2262static void 2263delete_failure_queue (void) 2264{ 2265 struct temp_file *temp; 2266 2267 for (temp = failure_delete_queue; temp; temp = temp->next) 2268 delete_if_ordinary (temp->name); 2269} 2270 2271static void 2272clear_failure_queue (void) 2273{ 2274 failure_delete_queue = 0; 2275} 2276 2277/* Build a list of search directories from PATHS. 2278 PREFIX is a string to prepend to the list. 2279 If CHECK_DIR_P is nonzero we ensure the directory exists. 2280 This is used mostly by putenv_from_prefixes so we use `collect_obstack'. 2281 It is also used by the --print-search-dirs flag. */ 2282 2283static char * 2284build_search_list (struct path_prefix *paths, const char *prefix, 2285 int check_dir_p) 2286{ 2287 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0; 2288 int just_suffix_len 2289 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0; 2290 int first_time = TRUE; 2291 struct prefix_list *pprefix; 2292 2293 obstack_grow (&collect_obstack, prefix, strlen (prefix)); 2294 obstack_1grow (&collect_obstack, '='); 2295 2296 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next) 2297 { 2298 int len = strlen (pprefix->prefix); 2299 2300 if (machine_suffix 2301 && (! check_dir_p 2302 || is_directory (pprefix->prefix, machine_suffix, 0))) 2303 { 2304 if (!first_time) 2305 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2306 2307 first_time = FALSE; 2308 obstack_grow (&collect_obstack, pprefix->prefix, len); 2309 obstack_grow (&collect_obstack, machine_suffix, suffix_len); 2310 } 2311 2312 if (just_machine_suffix 2313 && pprefix->require_machine_suffix == 2 2314 && (! check_dir_p 2315 || is_directory (pprefix->prefix, just_machine_suffix, 0))) 2316 { 2317 if (! first_time) 2318 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2319 2320 first_time = FALSE; 2321 obstack_grow (&collect_obstack, pprefix->prefix, len); 2322 obstack_grow (&collect_obstack, just_machine_suffix, 2323 just_suffix_len); 2324 } 2325 2326 if (! pprefix->require_machine_suffix) 2327 { 2328 if (! first_time) 2329 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2330 2331 first_time = FALSE; 2332 obstack_grow (&collect_obstack, pprefix->prefix, len); 2333 } 2334 } 2335 2336 obstack_1grow (&collect_obstack, '\0'); 2337 return obstack_finish (&collect_obstack); 2338} 2339 2340/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 2341 for collect. */ 2342 2343static void 2344putenv_from_prefixes (struct path_prefix *paths, const char *env_var) 2345{ 2346 putenv (build_search_list (paths, env_var, 1)); 2347} 2348 2349/* Check whether NAME can be accessed in MODE. This is like access, 2350 except that it never considers directories to be executable. */ 2351 2352static int 2353access_check (const char *name, int mode) 2354{ 2355 if (mode == X_OK) 2356 { 2357 struct stat st; 2358 2359 if (stat (name, &st) < 0 2360 || S_ISDIR (st.st_mode)) 2361 return -1; 2362 } 2363 2364 return access (name, mode); 2365} 2366 2367/* Search for NAME using the prefix list PREFIXES. MODE is passed to 2368 access to check permissions. 2369 Return 0 if not found, otherwise return its name, allocated with malloc. */ 2370 2371static char * 2372find_a_file (struct path_prefix *pprefix, const char *name, int mode, 2373 int multilib) 2374{ 2375 char *temp; 2376 const char *const file_suffix = 2377 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : ""); 2378 struct prefix_list *pl; 2379 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1; 2380 const char *multilib_name, *multilib_os_name; 2381 2382#ifdef DEFAULT_ASSEMBLER 2383 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) 2384 return xstrdup (DEFAULT_ASSEMBLER); 2385#endif 2386 2387#ifdef DEFAULT_LINKER 2388 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) 2389 return xstrdup (DEFAULT_LINKER); 2390#endif 2391 2392 if (machine_suffix) 2393 len += strlen (machine_suffix); 2394 2395 multilib_name = name; 2396 multilib_os_name = name; 2397 if (multilib && multilib_os_dir) 2398 { 2399 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0; 2400 int len2 = strlen (multilib_os_dir) + 1; 2401 2402 len += len1 > len2 ? len1 : len2; 2403 if (multilib_dir) 2404 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name, 2405 NULL)); 2406 if (strcmp (multilib_os_dir, ".") != 0) 2407 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name, 2408 NULL)); 2409 } 2410 2411 temp = xmalloc (len); 2412 2413 /* Determine the filename to execute (special case for absolute paths). */ 2414 2415 if (IS_ABSOLUTE_PATH (name)) 2416 { 2417 if (access (name, mode) == 0) 2418 { 2419 strcpy (temp, name); 2420 return temp; 2421 } 2422 } 2423 else 2424 for (pl = pprefix->plist; pl; pl = pl->next) 2425 { 2426 const char *this_name 2427 = pl->os_multilib ? multilib_os_name : multilib_name; 2428 2429 if (machine_suffix) 2430 { 2431 /* Some systems have a suffix for executable files. 2432 So try appending that first. */ 2433 if (file_suffix[0] != 0) 2434 { 2435 strcpy (temp, pl->prefix); 2436 strcat (temp, machine_suffix); 2437 strcat (temp, multilib_name); 2438 strcat (temp, file_suffix); 2439 if (access_check (temp, mode) == 0) 2440 { 2441 if (pl->used_flag_ptr != 0) 2442 *pl->used_flag_ptr = 1; 2443 return temp; 2444 } 2445 } 2446 2447 /* Now try just the multilib_name. */ 2448 strcpy (temp, pl->prefix); 2449 strcat (temp, machine_suffix); 2450 strcat (temp, multilib_name); 2451 if (access_check (temp, mode) == 0) 2452 { 2453 if (pl->used_flag_ptr != 0) 2454 *pl->used_flag_ptr = 1; 2455 return temp; 2456 } 2457 } 2458 2459 /* Certain prefixes are tried with just the machine type, 2460 not the version. This is used for finding as, ld, etc. */ 2461 if (just_machine_suffix && pl->require_machine_suffix == 2) 2462 { 2463 /* Some systems have a suffix for executable files. 2464 So try appending that first. */ 2465 if (file_suffix[0] != 0) 2466 { 2467 strcpy (temp, pl->prefix); 2468 strcat (temp, just_machine_suffix); 2469 strcat (temp, multilib_name); 2470 strcat (temp, file_suffix); 2471 if (access_check (temp, mode) == 0) 2472 { 2473 if (pl->used_flag_ptr != 0) 2474 *pl->used_flag_ptr = 1; 2475 return temp; 2476 } 2477 } 2478 2479 strcpy (temp, pl->prefix); 2480 strcat (temp, just_machine_suffix); 2481 strcat (temp, multilib_name); 2482 if (access_check (temp, mode) == 0) 2483 { 2484 if (pl->used_flag_ptr != 0) 2485 *pl->used_flag_ptr = 1; 2486 return temp; 2487 } 2488 } 2489 2490 /* Certain prefixes can't be used without the machine suffix 2491 when the machine or version is explicitly specified. */ 2492 if (! pl->require_machine_suffix) 2493 { 2494 /* Some systems have a suffix for executable files. 2495 So try appending that first. */ 2496 if (file_suffix[0] != 0) 2497 { 2498 strcpy (temp, pl->prefix); 2499 strcat (temp, this_name); 2500 strcat (temp, file_suffix); 2501 if (access_check (temp, mode) == 0) 2502 { 2503 if (pl->used_flag_ptr != 0) 2504 *pl->used_flag_ptr = 1; 2505 return temp; 2506 } 2507 } 2508 2509 strcpy (temp, pl->prefix); 2510 strcat (temp, this_name); 2511 if (access_check (temp, mode) == 0) 2512 { 2513 if (pl->used_flag_ptr != 0) 2514 *pl->used_flag_ptr = 1; 2515 return temp; 2516 } 2517 } 2518 } 2519 2520 free (temp); 2521 return 0; 2522} 2523 2524/* Ranking of prefixes in the sort list. -B prefixes are put before 2525 all others. */ 2526 2527enum path_prefix_priority 2528{ 2529 PREFIX_PRIORITY_B_OPT, 2530 PREFIX_PRIORITY_LAST 2531}; 2532 2533/* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending 2534 order according to PRIORITY. Within each PRIORITY, new entries are 2535 appended. 2536 2537 If WARN is nonzero, we will warn if no file is found 2538 through this prefix. WARN should point to an int 2539 which will be set to 1 if this entry is used. 2540 2541 COMPONENT is the value to be passed to update_path. 2542 2543 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without 2544 the complete value of machine_suffix. 2545 2 means try both machine_suffix and just_machine_suffix. */ 2546 2547static void 2548add_prefix (struct path_prefix *pprefix, const char *prefix, 2549 const char *component, /* enum prefix_priority */ int priority, 2550 int require_machine_suffix, int *warn, int os_multilib) 2551{ 2552 struct prefix_list *pl, **prev; 2553 int len; 2554 2555 for (prev = &pprefix->plist; 2556 (*prev) != NULL && (*prev)->priority <= priority; 2557 prev = &(*prev)->next) 2558 ; 2559 2560 /* Keep track of the longest prefix. */ 2561 2562 prefix = update_path (prefix, component); 2563 len = strlen (prefix); 2564 if (len > pprefix->max_len) 2565 pprefix->max_len = len; 2566 2567 pl = xmalloc (sizeof (struct prefix_list)); 2568 pl->prefix = prefix; 2569 pl->require_machine_suffix = require_machine_suffix; 2570 pl->used_flag_ptr = warn; 2571 pl->priority = priority; 2572 pl->os_multilib = os_multilib; 2573 if (warn) 2574 *warn = 0; 2575 2576 /* Insert after PREV. */ 2577 pl->next = (*prev); 2578 (*prev) = pl; 2579} 2580 2581/* Same as add_prefix, but prepending target_system_root to prefix. */ 2582static void 2583add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix, 2584 const char *component, 2585 /* enum prefix_priority */ int priority, 2586 int require_machine_suffix, int *warn, int os_multilib) 2587{ 2588 if (!IS_ABSOLUTE_PATH (prefix)) 2589 abort (); 2590 2591 if (target_system_root) 2592 { 2593 if (target_sysroot_suffix) 2594 prefix = concat (target_sysroot_suffix, prefix, NULL); 2595 prefix = concat (target_system_root, prefix, NULL); 2596 2597 /* We have to override this because GCC's notion of sysroot 2598 moves along with GCC. */ 2599 component = "GCC"; 2600 } 2601 2602 add_prefix (pprefix, prefix, component, priority, 2603 require_machine_suffix, warn, os_multilib); 2604} 2605 2606/* Execute the command specified by the arguments on the current line of spec. 2607 When using pipes, this includes several piped-together commands 2608 with `|' between them. 2609 2610 Return 0 if successful, -1 if failed. */ 2611 2612static int 2613execute (void) 2614{ 2615 int i; 2616 int n_commands; /* # of command. */ 2617 char *string; 2618 struct command 2619 { 2620 const char *prog; /* program name. */ 2621 const char **argv; /* vector of args. */ 2622 int pid; /* pid of process for this command. */ 2623 }; 2624 2625 struct command *commands; /* each command buffer with above info. */ 2626 2627 if (processing_spec_function) 2628 abort (); 2629 2630 /* Count # of piped commands. */ 2631 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2632 if (strcmp (argbuf[i], "|") == 0) 2633 n_commands++; 2634 2635 /* Get storage for each command. */ 2636 commands = alloca (n_commands * sizeof (struct command)); 2637 2638 /* Split argbuf into its separate piped processes, 2639 and record info about each one. 2640 Also search for the programs that are to be run. */ 2641 2642 commands[0].prog = argbuf[0]; /* first command. */ 2643 commands[0].argv = &argbuf[0]; 2644 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0); 2645 2646 if (string) 2647 commands[0].argv[0] = string; 2648 2649 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2650 if (strcmp (argbuf[i], "|") == 0) 2651 { /* each command. */ 2652#if defined (__MSDOS__) || defined (OS2) || defined (VMS) 2653 fatal ("-pipe not supported"); 2654#endif 2655 argbuf[i] = 0; /* termination of command args. */ 2656 commands[n_commands].prog = argbuf[i + 1]; 2657 commands[n_commands].argv = &argbuf[i + 1]; 2658 string = find_a_file (&exec_prefixes, commands[n_commands].prog, 2659 X_OK, 0); 2660 if (string) 2661 commands[n_commands].argv[0] = string; 2662 n_commands++; 2663 } 2664 2665 argbuf[argbuf_index] = 0; 2666 2667 /* If -v, print what we are about to do, and maybe query. */ 2668 2669 if (verbose_flag) 2670 { 2671 /* For help listings, put a blank line between sub-processes. */ 2672 if (print_help_list) 2673 fputc ('\n', stderr); 2674 2675 /* Print each piped command as a separate line. */ 2676 for (i = 0; i < n_commands; i++) 2677 { 2678 const char *const *j; 2679 2680 if (verbose_only_flag) 2681 { 2682 for (j = commands[i].argv; *j; j++) 2683 { 2684 const char *p; 2685 fprintf (stderr, " \""); 2686 for (p = *j; *p; ++p) 2687 { 2688 if (*p == '"' || *p == '\\' || *p == '$') 2689 fputc ('\\', stderr); 2690 fputc (*p, stderr); 2691 } 2692 fputc ('"', stderr); 2693 } 2694 } 2695 else 2696 for (j = commands[i].argv; *j; j++) 2697 fprintf (stderr, " %s", *j); 2698 2699 /* Print a pipe symbol after all but the last command. */ 2700 if (i + 1 != n_commands) 2701 fprintf (stderr, " |"); 2702 fprintf (stderr, "\n"); 2703 } 2704 fflush (stderr); 2705 if (verbose_only_flag != 0) 2706 { 2707 /* verbose_only_flag should act as if the spec was 2708 executed, so increment execution_count before 2709 returning. This prevents spurious warnings about 2710 unused linker input files, etc. */ 2711 execution_count++; 2712 return 0; 2713 } 2714#ifdef DEBUG 2715 notice ("\nGo ahead? (y or n) "); 2716 fflush (stderr); 2717 i = getchar (); 2718 if (i != '\n') 2719 while (getchar () != '\n') 2720 ; 2721 2722 if (i != 'y' && i != 'Y') 2723 return 0; 2724#endif /* DEBUG */ 2725 } 2726 2727#ifdef ENABLE_VALGRIND_CHECKING 2728 /* Run the each command through valgrind. To simplify prepending the 2729 path to valgrind and the option "-q" (for quiet operation unless 2730 something triggers), we allocate a separate argv array. */ 2731 2732 for (i = 0; i < n_commands; i++) 2733 { 2734 const char **argv; 2735 int argc; 2736 int j; 2737 2738 for (argc = 0; commands[i].argv[argc] != NULL; argc++) 2739 ; 2740 2741 argv = alloca ((argc + 3) * sizeof (char *)); 2742 2743 argv[0] = VALGRIND_PATH; 2744 argv[1] = "-q"; 2745 for (j = 2; j < argc + 2; j++) 2746 argv[j] = commands[i].argv[j - 2]; 2747 argv[j] = NULL; 2748 2749 commands[i].argv = argv; 2750 commands[i].prog = argv[0]; 2751 } 2752#endif 2753 2754 /* Run each piped subprocess. */ 2755 2756 for (i = 0; i < n_commands; i++) 2757 { 2758 char *errmsg_fmt, *errmsg_arg; 2759 const char *string = commands[i].argv[0]; 2760 2761 /* For some bizarre reason, the second argument of execvp() is 2762 char *const *, not const char *const *. */ 2763 commands[i].pid = pexecute (string, (char *const *) commands[i].argv, 2764 programname, temp_filename, 2765 &errmsg_fmt, &errmsg_arg, 2766 ((i == 0 ? PEXECUTE_FIRST : 0) 2767 | (i + 1 == n_commands ? PEXECUTE_LAST : 0) 2768 | (string == commands[i].prog 2769 ? PEXECUTE_SEARCH : 0) 2770 | (verbose_flag ? PEXECUTE_VERBOSE : 0))); 2771 2772 if (commands[i].pid == -1) 2773 pfatal_pexecute (errmsg_fmt, errmsg_arg); 2774 2775 if (string != commands[i].prog) 2776 free ((void *) string); 2777 } 2778 2779 execution_count++; 2780 2781 /* Wait for all the subprocesses to finish. 2782 We don't care what order they finish in; 2783 we know that N_COMMANDS waits will get them all. 2784 Ignore subprocesses that we don't know about, 2785 since they can be spawned by the process that exec'ed us. */ 2786 2787 { 2788 int ret_code = 0; 2789#ifdef HAVE_GETRUSAGE 2790 struct timeval d; 2791 double ut = 0.0, st = 0.0; 2792#endif 2793 2794 for (i = 0; i < n_commands;) 2795 { 2796 int j; 2797 int status; 2798 int pid; 2799 2800 pid = pwait (commands[i].pid, &status, 0); 2801 if (pid < 0) 2802 abort (); 2803 2804#ifdef HAVE_GETRUSAGE 2805 if (report_times) 2806 { 2807 /* getrusage returns the total resource usage of all children 2808 up to now. Copy the previous values into prus, get the 2809 current statistics, then take the difference. */ 2810 2811 prus = rus; 2812 getrusage (RUSAGE_CHILDREN, &rus); 2813 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec; 2814 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec; 2815 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2816 2817 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec; 2818 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec; 2819 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2820 } 2821#endif 2822 2823 for (j = 0; j < n_commands; j++) 2824 if (commands[j].pid == pid) 2825 { 2826 i++; 2827 if (WIFSIGNALED (status)) 2828 { 2829#ifdef SIGPIPE 2830 /* SIGPIPE is a special case. It happens in -pipe mode 2831 when the compiler dies before the preprocessor is 2832 done, or the assembler dies before the compiler is 2833 done. There's generally been an error already, and 2834 this is just fallout. So don't generate another error 2835 unless we would otherwise have succeeded. */ 2836 if (WTERMSIG (status) == SIGPIPE 2837 && (signal_count || greatest_status >= MIN_FATAL_STATUS)) 2838 ; 2839 else 2840#endif 2841 fatal ("\ 2842Internal error: %s (program %s)\n\ 2843Please submit a full bug report.\n\ 2844See %s for instructions.", 2845 strsignal (WTERMSIG (status)), commands[j].prog, 2846 bug_report_url); 2847 signal_count++; 2848 ret_code = -1; 2849 } 2850 else if (WIFEXITED (status) 2851 && WEXITSTATUS (status) >= MIN_FATAL_STATUS) 2852 { 2853 if (WEXITSTATUS (status) > greatest_status) 2854 greatest_status = WEXITSTATUS (status); 2855 ret_code = -1; 2856 } 2857#ifdef HAVE_GETRUSAGE 2858 if (report_times && ut + st != 0) 2859 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st); 2860#endif 2861 break; 2862 } 2863 } 2864 return ret_code; 2865 } 2866} 2867 2868/* Find all the switches given to us 2869 and make a vector describing them. 2870 The elements of the vector are strings, one per switch given. 2871 If a switch uses following arguments, then the `part1' field 2872 is the switch itself and the `args' field 2873 is a null-terminated vector containing the following arguments. 2874 The `live_cond' field is: 2875 0 when initialized 2876 1 if the switch is true in a conditional spec, 2877 -1 if false (overridden by a later switch) 2878 -2 if this switch should be ignored (used in %<S) 2879 The `validated' field is nonzero if any spec has looked at this switch; 2880 if it remains zero at the end of the run, it must be meaningless. */ 2881 2882#define SWITCH_OK 0 2883#define SWITCH_FALSE -1 2884#define SWITCH_IGNORE -2 2885#define SWITCH_LIVE 1 2886 2887struct switchstr 2888{ 2889 const char *part1; 2890 const char **args; 2891 int live_cond; 2892 unsigned char validated; 2893 unsigned char ordering; 2894}; 2895 2896static struct switchstr *switches; 2897 2898static int n_switches; 2899 2900struct infile 2901{ 2902 const char *name; 2903 const char *language; 2904}; 2905 2906/* Also a vector of input files specified. */ 2907 2908static struct infile *infiles; 2909 2910int n_infiles; 2911 2912/* True if multiple input files are being compiled to a single 2913 assembly file. */ 2914 2915static bool combine_inputs; 2916 2917/* This counts the number of libraries added by lang_specific_driver, so that 2918 we can tell if there were any user supplied any files or libraries. */ 2919 2920static int added_libraries; 2921 2922/* And a vector of corresponding output files is made up later. */ 2923 2924const char **outfiles; 2925 2926/* Used to track if none of the -B paths are used. */ 2927static int warn_B; 2928 2929/* Gives value to pass as "warn" to add_prefix for standard prefixes. */ 2930static int *warn_std_ptr = 0; 2931 2932#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2933 2934/* Convert NAME to a new name if it is the standard suffix. DO_EXE 2935 is true if we should look for an executable suffix. DO_OBJ 2936 is true if we should look for an object suffix. */ 2937 2938static const char * 2939convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED, 2940 int do_obj ATTRIBUTE_UNUSED) 2941{ 2942#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2943 int i; 2944#endif 2945 int len; 2946 2947 if (name == NULL) 2948 return NULL; 2949 2950 len = strlen (name); 2951 2952#ifdef HAVE_TARGET_OBJECT_SUFFIX 2953 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */ 2954 if (do_obj && len > 2 2955 && name[len - 2] == '.' 2956 && name[len - 1] == 'o') 2957 { 2958 obstack_grow (&obstack, name, len - 2); 2959 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 2960 name = obstack_finish (&obstack); 2961 } 2962#endif 2963 2964#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2965 /* If there is no filetype, make it the executable suffix (which includes 2966 the "."). But don't get confused if we have just "-o". */ 2967 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-')) 2968 return name; 2969 2970 for (i = len - 1; i >= 0; i--) 2971 if (IS_DIR_SEPARATOR (name[i])) 2972 break; 2973 2974 for (i++; i < len; i++) 2975 if (name[i] == '.') 2976 return name; 2977 2978 obstack_grow (&obstack, name, len); 2979 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX, 2980 strlen (TARGET_EXECUTABLE_SUFFIX)); 2981 name = obstack_finish (&obstack); 2982#endif 2983 2984 return name; 2985} 2986#endif 2987 2988/* Display the command line switches accepted by gcc. */ 2989static void 2990display_help (void) 2991{ 2992 printf (_("Usage: %s [options] file...\n"), programname); 2993 fputs (_("Options:\n"), stdout); 2994 2995 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout); 2996 fputs (_(" --help Display this information\n"), stdout); 2997 fputs (_(" --target-help Display target specific command line options\n"), stdout); 2998 if (! verbose_flag) 2999 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout); 3000 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout); 3001 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout); 3002 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout); 3003 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout); 3004 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout); 3005 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout); 3006 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout); 3007 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout); 3008 fputs (_("\ 3009 -print-multi-lib Display the mapping between command line options and\n\ 3010 multiple library search directories\n"), stdout); 3011 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout); 3012 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout); 3013 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout); 3014 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout); 3015 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout); 3016 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout); 3017 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout); 3018 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout); 3019 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout); 3020 fputs (_(" -time Time the execution of each subprocess\n"), stdout); 3021 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout); 3022 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout); 3023 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout); 3024 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout); 3025 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout); 3026 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout); 3027 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout); 3028 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout); 3029 fputs (_(" -S Compile only; do not assemble or link\n"), stdout); 3030 fputs (_(" -c Compile and assemble, but do not link\n"), stdout); 3031 fputs (_(" -o <file> Place the output into <file>\n"), stdout); 3032 fputs (_("\ 3033 -x <language> Specify the language of the following input files\n\ 3034 Permissible languages include: c c++ assembler none\n\ 3035 'none' means revert to the default behavior of\n\ 3036 guessing the language based on the file's extension\n\ 3037"), stdout); 3038 3039 printf (_("\ 3040\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\ 3041 passed on to the various sub-processes invoked by %s. In order to pass\n\ 3042 other options on to these processes the -W<letter> options must be used.\n\ 3043"), programname); 3044 3045 /* The rest of the options are displayed by invocations of the various 3046 sub-processes. */ 3047} 3048 3049static void 3050add_preprocessor_option (const char *option, int len) 3051{ 3052 n_preprocessor_options++; 3053 3054 if (! preprocessor_options) 3055 preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *)); 3056 else 3057 preprocessor_options = xrealloc (preprocessor_options, 3058 n_preprocessor_options * sizeof (char *)); 3059 3060 preprocessor_options [n_preprocessor_options - 1] = 3061 save_string (option, len); 3062} 3063 3064static void 3065add_assembler_option (const char *option, int len) 3066{ 3067 n_assembler_options++; 3068 3069 if (! assembler_options) 3070 assembler_options = xmalloc (n_assembler_options * sizeof (char *)); 3071 else 3072 assembler_options = xrealloc (assembler_options, 3073 n_assembler_options * sizeof (char *)); 3074 3075 assembler_options [n_assembler_options - 1] = save_string (option, len); 3076} 3077 3078static void 3079add_linker_option (const char *option, int len) 3080{ 3081 n_linker_options++; 3082 3083 if (! linker_options) 3084 linker_options = xmalloc (n_linker_options * sizeof (char *)); 3085 else 3086 linker_options = xrealloc (linker_options, 3087 n_linker_options * sizeof (char *)); 3088 3089 linker_options [n_linker_options - 1] = save_string (option, len); 3090} 3091 3092/* Create the vector `switches' and its contents. 3093 Store its length in `n_switches'. */ 3094 3095static void 3096process_command (int argc, const char **argv) 3097{ 3098 int i; 3099 const char *temp; 3100 char *temp1; 3101 const char *spec_lang = 0; 3102 int last_language_n_infiles; 3103 int have_c = 0; 3104 int have_o = 0; 3105 int lang_n_infiles = 0; 3106#ifdef MODIFY_TARGET_NAME 3107 int is_modify_target_name; 3108 int j; 3109#endif 3110 3111 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX"); 3112 3113 n_switches = 0; 3114 n_infiles = 0; 3115 added_libraries = 0; 3116 3117 /* Figure compiler version from version string. */ 3118 3119 compiler_version = temp1 = xstrdup (version_string); 3120 3121 for (; *temp1; ++temp1) 3122 { 3123 if (*temp1 == ' ') 3124 { 3125 *temp1 = '\0'; 3126 break; 3127 } 3128 } 3129 3130 /* If there is a -V or -b option (or both), process it now, before 3131 trying to interpret the rest of the command line. */ 3132 if (argc > 1 && argv[1][0] == '-' 3133 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3134 { 3135 const char *new_version = DEFAULT_TARGET_VERSION; 3136 const char *new_machine = DEFAULT_TARGET_MACHINE; 3137 const char *progname = argv[0]; 3138 char **new_argv; 3139 char *new_argv0; 3140 int baselen; 3141 3142 while (argc > 1 && argv[1][0] == '-' 3143 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3144 { 3145 char opt = argv[1][1]; 3146 const char *arg; 3147 if (argv[1][2] != '\0') 3148 { 3149 arg = argv[1] + 2; 3150 argc -= 1; 3151 argv += 1; 3152 } 3153 else if (argc > 2) 3154 { 3155 arg = argv[2]; 3156 argc -= 2; 3157 argv += 2; 3158 } 3159 else 3160 fatal ("`-%c' option must have argument", opt); 3161 if (opt == 'V') 3162 new_version = arg; 3163 else 3164 new_machine = arg; 3165 } 3166 3167 for (baselen = strlen (progname); baselen > 0; baselen--) 3168 if (IS_DIR_SEPARATOR (progname[baselen-1])) 3169 break; 3170 new_argv0 = xmemdup (progname, baselen, 3171 baselen + concat_length (new_version, new_machine, 3172 "-gcc-", NULL) + 1); 3173 strcpy (new_argv0 + baselen, new_machine); 3174 strcat (new_argv0, "-gcc-"); 3175 strcat (new_argv0, new_version); 3176 3177 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]), 3178 (argc + 1) * sizeof (argv[0])); 3179 new_argv[0] = new_argv0; 3180 3181 execvp (new_argv0, new_argv); 3182 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno)); 3183 } 3184 3185 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX, 3186 see if we can create it from the pathname specified in argv[0]. */ 3187 3188 gcc_libexec_prefix = standard_libexec_prefix; 3189#ifndef FREEBSD_NATIVE 3190#ifndef VMS 3191 /* FIXME: make_relative_prefix doesn't yet work for VMS. */ 3192 if (!gcc_exec_prefix) 3193 { 3194 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix, 3195 standard_exec_prefix); 3196 gcc_libexec_prefix = make_relative_prefix (argv[0], 3197 standard_bindir_prefix, 3198 standard_libexec_prefix); 3199 if (gcc_exec_prefix) 3200 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL)); 3201 } 3202 else 3203 gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix, 3204 standard_exec_prefix, 3205 standard_libexec_prefix); 3206#else 3207#endif 3208#endif /* not FREEBSD_NATIVE */ 3209 3210 if (gcc_exec_prefix) 3211 { 3212 int len = strlen (gcc_exec_prefix); 3213 3214 if (len > (int) sizeof ("/lib/gcc/") - 1 3215 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1]))) 3216 { 3217 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1; 3218 if (IS_DIR_SEPARATOR (*temp) 3219 && strncmp (temp + 1, "lib", 3) == 0 3220 && IS_DIR_SEPARATOR (temp[4]) 3221 && strncmp (temp + 5, "gcc", 3) == 0) 3222 len -= sizeof ("/lib/gcc/") - 1; 3223 } 3224 3225 set_std_prefix (gcc_exec_prefix, len); 3226 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC", 3227 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3228 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 3229 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3230 } 3231 3232 /* COMPILER_PATH and LIBRARY_PATH have values 3233 that are lists of directory names with colons. */ 3234 3235 GET_ENVIRONMENT (temp, "COMPILER_PATH"); 3236 if (temp) 3237 { 3238 const char *startp, *endp; 3239 char *nstore = alloca (strlen (temp) + 3); 3240 3241 startp = endp = temp; 3242 while (1) 3243 { 3244 if (*endp == PATH_SEPARATOR || *endp == 0) 3245 { 3246 strncpy (nstore, startp, endp - startp); 3247 if (endp == startp) 3248 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3249 else if (!IS_DIR_SEPARATOR (endp[-1])) 3250 { 3251 nstore[endp - startp] = DIR_SEPARATOR; 3252 nstore[endp - startp + 1] = 0; 3253 } 3254 else 3255 nstore[endp - startp] = 0; 3256 add_prefix (&exec_prefixes, nstore, 0, 3257 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3258 add_prefix (&include_prefixes, 3259 concat (nstore, "include", NULL), 3260 0, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3261 if (*endp == 0) 3262 break; 3263 endp = startp = endp + 1; 3264 } 3265 else 3266 endp++; 3267 } 3268 } 3269 3270 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV); 3271 if (temp && *cross_compile == '0') 3272 { 3273 const char *startp, *endp; 3274 char *nstore = alloca (strlen (temp) + 3); 3275 3276 startp = endp = temp; 3277 while (1) 3278 { 3279 if (*endp == PATH_SEPARATOR || *endp == 0) 3280 { 3281 strncpy (nstore, startp, endp - startp); 3282 if (endp == startp) 3283 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3284 else if (!IS_DIR_SEPARATOR (endp[-1])) 3285 { 3286 nstore[endp - startp] = DIR_SEPARATOR; 3287 nstore[endp - startp + 1] = 0; 3288 } 3289 else 3290 nstore[endp - startp] = 0; 3291 add_prefix (&startfile_prefixes, nstore, NULL, 3292 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3293 if (*endp == 0) 3294 break; 3295 endp = startp = endp + 1; 3296 } 3297 else 3298 endp++; 3299 } 3300 } 3301 3302 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */ 3303 GET_ENVIRONMENT (temp, "LPATH"); 3304 if (temp && *cross_compile == '0') 3305 { 3306 const char *startp, *endp; 3307 char *nstore = alloca (strlen (temp) + 3); 3308 3309 startp = endp = temp; 3310 while (1) 3311 { 3312 if (*endp == PATH_SEPARATOR || *endp == 0) 3313 { 3314 strncpy (nstore, startp, endp - startp); 3315 if (endp == startp) 3316 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3317 else if (!IS_DIR_SEPARATOR (endp[-1])) 3318 { 3319 nstore[endp - startp] = DIR_SEPARATOR; 3320 nstore[endp - startp + 1] = 0; 3321 } 3322 else 3323 nstore[endp - startp] = 0; 3324 add_prefix (&startfile_prefixes, nstore, NULL, 3325 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3326 if (*endp == 0) 3327 break; 3328 endp = startp = endp + 1; 3329 } 3330 else 3331 endp++; 3332 } 3333 } 3334 3335 /* Options specified as if they appeared on the command line. */ 3336 temp = getenv ("GCC_OPTIONS"); 3337 if ((temp) && (strlen (temp) > 0)) 3338 { 3339 int len; 3340 int optc = 1; 3341 int new_argc; 3342 const char **new_argv; 3343 char *envopts; 3344 3345 while (isspace (*temp)) 3346 temp++; 3347 len = strlen (temp); 3348 envopts = (char *) xmalloc (len + 1); 3349 strcpy (envopts, temp); 3350 3351 for (i = 0; i < (len - 1); i++) 3352 if ((isspace (envopts[i])) && ! (isspace (envopts[i+1]))) 3353 optc++; 3354 3355 new_argv = (const char **) alloca ((optc + argc) * sizeof(char *)); 3356 3357 for (i = 0, new_argc = 1; new_argc <= optc; new_argc++) 3358 { 3359 while (isspace (envopts[i])) 3360 i++; 3361 new_argv[new_argc] = envopts + i; 3362 while (!isspace (envopts[i]) && (envopts[i] != '\0')) 3363 i++; 3364 envopts[i++] = '\0'; 3365 } 3366 for (i = 1; i < argc; i++) 3367 new_argv[new_argc++] = argv[i]; 3368 3369 argv = new_argv; 3370 argc = new_argc; 3371 } 3372 3373 /* Convert new-style -- options to old-style. */ 3374 translate_options (&argc, (const char *const **) &argv); 3375 3376 /* Do language-specific adjustment/addition of flags. */ 3377 lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries); 3378 3379 /* Scan argv twice. Here, the first time, just count how many switches 3380 there will be in their vector, and how many input files in theirs. 3381 Here we also parse the switches that cc itself uses (e.g. -v). */ 3382 3383 for (i = 1; i < argc; i++) 3384 { 3385 if (! strcmp (argv[i], "-dumpspecs")) 3386 { 3387 struct spec_list *sl; 3388 init_spec (); 3389 for (sl = specs; sl; sl = sl->next) 3390 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec)); 3391 if (link_command_spec) 3392 printf ("*link_command:\n%s\n\n", link_command_spec); 3393 exit (0); 3394 } 3395 else if (! strcmp (argv[i], "-dumpversion")) 3396 { 3397 printf ("%s\n", spec_version); 3398 exit (0); 3399 } 3400 else if (! strcmp (argv[i], "-dumpmachine")) 3401 { 3402 printf ("%s\n", spec_machine); 3403 exit (0); 3404 } 3405 else if (strcmp (argv[i], "-fversion") == 0) 3406 { 3407 /* translate_options () has turned --version into -fversion. */ 3408 printf (_("%s (GCC) %s\n"), programname, version_string);
| 28 29/* This program is the user interface to the C compiler and possibly to 30other compilers. It is used because compilation is a complicated procedure 31which involves running several programs and passing temporary files between 32them, forwarding the users switches to those programs selectively, 33and deleting the temporary files at the end. 34 35CC recognizes how to compile each input file by suffixes in the file names. 36Once it knows which kind of compilation to perform, the procedure for 37compilation is specified by a string called a "spec". */ 38 39/* A Short Introduction to Adding a Command-Line Option. 40 41 Before adding a command-line option, consider if it is really 42 necessary. Each additional command-line option adds complexity and 43 is difficult to remove in subsequent versions. 44 45 In the following, consider adding the command-line argument 46 `--bar'. 47 48 1. Each command-line option is specified in the specs file. The 49 notation is described below in the comment entitled "The Specs 50 Language". Read it. 51 52 2. In this file, add an entry to "option_map" equating the long 53 `--' argument version and any shorter, single letter version. Read 54 the comments in the declaration of "struct option_map" for an 55 explanation. Do not omit the first `-'. 56 57 3. Look in the "specs" file to determine which program or option 58 list should be given the argument, e.g., "cc1_options". Add the 59 appropriate syntax for the shorter option version to the 60 corresponding "const char *" entry in this file. Omit the first 61 `-' from the option. For example, use `-bar', rather than `--bar'. 62 63 4. If the argument takes an argument, e.g., `--baz argument1', 64 modify either DEFAULT_SWITCH_TAKES_ARG or 65 DEFAULT_WORD_SWITCH_TAKES_ARG in this file. Omit the first `-' 66 from `--baz'. 67 68 5. Document the option in this file's display_help(). If the 69 option is passed to a subprogram, modify its corresponding 70 function, e.g., cppinit.c:print_help() or toplev.c:display_help(), 71 instead. 72 73 6. Compile and test. Make sure that your new specs file is being 74 read. For example, use a debugger to investigate the value of 75 "specs_file" in main(). */ 76 77#include "config.h" 78#include "system.h" 79#include "coretypes.h" 80#include "multilib.h" /* before tm.h */ 81#include "tm.h" 82#include <signal.h> 83#if ! defined( SIGCHLD ) && defined( SIGCLD ) 84# define SIGCHLD SIGCLD 85#endif 86#include "obstack.h" 87#include "intl.h" 88#include "prefix.h" 89#include "gcc.h" 90#include "flags.h" 91 92#ifdef HAVE_SYS_RESOURCE_H 93#include <sys/resource.h> 94#endif 95#if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE 96extern int getrusage (int, struct rusage *); 97#endif 98 99/* By default there is no special suffix for target executables. */ 100/* FIXME: when autoconf is fixed, remove the host check - dj */ 101#if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX) 102#define HAVE_TARGET_EXECUTABLE_SUFFIX 103#endif 104 105/* By default there is no special suffix for host executables. */ 106#ifdef HOST_EXECUTABLE_SUFFIX 107#define HAVE_HOST_EXECUTABLE_SUFFIX 108#else 109#define HOST_EXECUTABLE_SUFFIX "" 110#endif 111 112/* By default, the suffix for target object files is ".o". */ 113#ifdef TARGET_OBJECT_SUFFIX 114#define HAVE_TARGET_OBJECT_SUFFIX 115#else 116#define TARGET_OBJECT_SUFFIX ".o" 117#endif 118 119static const char dir_separator_str[] = { DIR_SEPARATOR, 0 }; 120 121/* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */ 122#ifndef LIBRARY_PATH_ENV 123#define LIBRARY_PATH_ENV "LIBRARY_PATH" 124#endif 125 126#ifndef HAVE_KILL 127#define kill(p,s) raise(s) 128#endif 129 130/* If a stage of compilation returns an exit status >= 1, 131 compilation of that file ceases. */ 132 133#define MIN_FATAL_STATUS 1 134 135/* Flag set by cppspec.c to 1. */ 136int is_cpp_driver; 137 138/* Flag saying to pass the greatest exit code returned by a sub-process 139 to the calling program. */ 140static int pass_exit_codes; 141 142/* Definition of string containing the arguments given to configure. */ 143#include "configargs.h" 144 145/* Flag saying to print the directories gcc will search through looking for 146 programs, libraries, etc. */ 147 148static int print_search_dirs; 149 150/* Flag saying to print the full filename of this file 151 as found through our usual search mechanism. */ 152 153static const char *print_file_name = NULL; 154 155/* As print_file_name, but search for executable file. */ 156 157static const char *print_prog_name = NULL; 158 159/* Flag saying to print the relative path we'd use to 160 find libgcc.a given the current compiler flags. */ 161 162static int print_multi_directory; 163 164/* Flag saying to print the relative path we'd use to 165 find OS libraries given the current compiler flags. */ 166 167static int print_multi_os_directory; 168 169/* Flag saying to print the list of subdirectories and 170 compiler flags used to select them in a standard form. */ 171 172static int print_multi_lib; 173 174/* Flag saying to print the command line options understood by gcc and its 175 sub-processes. */ 176 177static int print_help_list; 178 179/* Flag indicating whether we should print the command and arguments */ 180 181static int verbose_flag; 182 183/* Flag indicating whether we should ONLY print the command and 184 arguments (like verbose_flag) without executing the command. 185 Displayed arguments are quoted so that the generated command 186 line is suitable for execution. This is intended for use in 187 shell scripts to capture the driver-generated command line. */ 188static int verbose_only_flag; 189 190/* Flag indicating to print target specific command line options. */ 191 192static int target_help_flag; 193 194/* Flag indicating whether we should report subprocess execution times 195 (if this is supported by the system - see pexecute.c). */ 196 197static int report_times; 198 199/* Nonzero means place this string before uses of /, so that include 200 and library files can be found in an alternate location. */ 201 202#ifdef TARGET_SYSTEM_ROOT 203static const char *target_system_root = TARGET_SYSTEM_ROOT; 204#else 205static const char *target_system_root = 0; 206#endif 207 208/* Nonzero means pass the updated target_system_root to the compiler. */ 209 210static int target_system_root_changed; 211 212/* Nonzero means append this string to target_system_root. */ 213 214static const char *target_sysroot_suffix = 0; 215 216/* Nonzero means append this string to target_system_root for headers. */ 217 218static const char *target_sysroot_hdrs_suffix = 0; 219 220/* Nonzero means write "temp" files in source directory 221 and use the source file's name in them, and don't delete them. */ 222 223static int save_temps_flag; 224 225/* Nonzero means use pipes to communicate between subprocesses. 226 Overridden by either of the above two flags. */ 227 228static int use_pipes; 229 230/* The compiler version. */ 231 232static const char *compiler_version; 233 234/* The target version specified with -V */ 235 236static const char *const spec_version = DEFAULT_TARGET_VERSION; 237 238/* The target machine specified with -b. */ 239 240static const char *spec_machine = DEFAULT_TARGET_MACHINE; 241 242/* Nonzero if cross-compiling. 243 When -b is used, the value comes from the `specs' file. */ 244 245#ifdef CROSS_COMPILE 246static const char *cross_compile = "1"; 247#else 248static const char *cross_compile = "0"; 249#endif 250 251#ifdef MODIFY_TARGET_NAME 252 253/* Information on how to alter the target name based on a command-line 254 switch. The only case we support now is simply appending or deleting a 255 string to or from the end of the first part of the configuration name. */ 256 257static const struct modify_target 258{ 259 const char *const sw; 260 const enum add_del {ADD, DELETE} add_del; 261 const char *const str; 262} 263modify_target[] = MODIFY_TARGET_NAME; 264#endif 265 266/* The number of errors that have occurred; the link phase will not be 267 run if this is nonzero. */ 268static int error_count = 0; 269 270/* Greatest exit code of sub-processes that has been encountered up to 271 now. */ 272static int greatest_status = 1; 273 274/* This is the obstack which we use to allocate many strings. */ 275 276static struct obstack obstack; 277 278/* This is the obstack to build an environment variable to pass to 279 collect2 that describes all of the relevant switches of what to 280 pass the compiler in building the list of pointers to constructors 281 and destructors. */ 282 283static struct obstack collect_obstack; 284 285/* These structs are used to collect resource usage information for 286 subprocesses. */ 287#ifdef HAVE_GETRUSAGE 288static struct rusage rus, prus; 289#endif 290 291/* Forward declaration for prototypes. */ 292struct path_prefix; 293 294static void init_spec (void); 295static void store_arg (const char *, int, int); 296static char *load_specs (const char *); 297static void read_specs (const char *, int); 298static void set_spec (const char *, const char *); 299static struct compiler *lookup_compiler (const char *, size_t, const char *); 300static char *build_search_list (struct path_prefix *, const char *, int); 301static void putenv_from_prefixes (struct path_prefix *, const char *); 302static int access_check (const char *, int); 303static char *find_a_file (struct path_prefix *, const char *, int, int); 304static void add_prefix (struct path_prefix *, const char *, const char *, 305 int, int, int *, int); 306static void add_sysrooted_prefix (struct path_prefix *, const char *, 307 const char *, int, int, int *, int); 308static void translate_options (int *, const char *const **); 309static char *skip_whitespace (char *); 310static void delete_if_ordinary (const char *); 311static void delete_temp_files (void); 312static void delete_failure_queue (void); 313static void clear_failure_queue (void); 314static int check_live_switch (int, int); 315static const char *handle_braces (const char *); 316static inline bool input_suffix_matches (const char *, const char *); 317static inline bool switch_matches (const char *, const char *, int); 318static inline void mark_matching_switches (const char *, const char *, int); 319static inline void process_marked_switches (void); 320static const char *process_brace_body (const char *, const char *, const char *, int, int); 321static const struct spec_function *lookup_spec_function (const char *); 322static const char *eval_spec_function (const char *, const char *); 323static const char *handle_spec_function (const char *); 324static char *save_string (const char *, int); 325static void set_collect_gcc_options (void); 326static int do_spec_1 (const char *, int, const char *); 327static int do_spec_2 (const char *); 328static void do_option_spec (const char *, const char *); 329static void do_self_spec (const char *); 330static const char *find_file (const char *); 331static int is_directory (const char *, const char *, int); 332static const char *validate_switches (const char *); 333static void validate_all_switches (void); 334static inline void validate_switches_from_spec (const char *); 335static void give_switch (int, int); 336static int used_arg (const char *, int); 337static int default_arg (const char *, int); 338static void set_multilib_dir (void); 339static void print_multilib_info (void); 340static void perror_with_name (const char *); 341static void pfatal_pexecute (const char *, const char *) ATTRIBUTE_NORETURN; 342static void notice (const char *, ...) ATTRIBUTE_PRINTF_1; 343static void display_help (void); 344static void add_preprocessor_option (const char *, int); 345static void add_assembler_option (const char *, int); 346static void add_linker_option (const char *, int); 347static void process_command (int, const char **); 348static int execute (void); 349static void alloc_args (void); 350static void clear_args (void); 351static void fatal_error (int); 352#ifdef ENABLE_SHARED_LIBGCC 353static void init_gcc_specs (struct obstack *, const char *, const char *, 354 const char *); 355#endif 356#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 357static const char *convert_filename (const char *, int, int); 358#endif 359 360static const char *if_exists_spec_function (int, const char **); 361static const char *if_exists_else_spec_function (int, const char **); 362 363/* The Specs Language 364 365Specs are strings containing lines, each of which (if not blank) 366is made up of a program name, and arguments separated by spaces. 367The program name must be exact and start from root, since no path 368is searched and it is unreliable to depend on the current working directory. 369Redirection of input or output is not supported; the subprograms must 370accept filenames saying what files to read and write. 371 372In addition, the specs can contain %-sequences to substitute variable text 373or for conditional text. Here is a table of all defined %-sequences. 374Note that spaces are not generated automatically around the results of 375expanding these sequences; therefore, you can concatenate them together 376or with constant text in a single argument. 377 378 %% substitute one % into the program name or argument. 379 %i substitute the name of the input file being processed. 380 %b substitute the basename of the input file being processed. 381 This is the substring up to (and not including) the last period 382 and not including the directory. 383 %B same as %b, but include the file suffix (text after the last period). 384 %gSUFFIX 385 substitute a file name that has suffix SUFFIX and is chosen 386 once per compilation, and mark the argument a la %d. To reduce 387 exposure to denial-of-service attacks, the file name is now 388 chosen in a way that is hard to predict even when previously 389 chosen file names are known. For example, `%g.s ... %g.o ... %g.s' 390 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches 391 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it 392 had been pre-processed. Previously, %g was simply substituted 393 with a file name chosen once per compilation, without regard 394 to any appended suffix (which was therefore treated just like 395 ordinary text), making such attacks more likely to succeed. 396 %|SUFFIX 397 like %g, but if -pipe is in effect, expands simply to "-". 398 %mSUFFIX 399 like %g, but if -pipe is in effect, expands to nothing. (We have both 400 %| and %m to accommodate differences between system assemblers; see 401 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.) 402 %uSUFFIX 403 like %g, but generates a new temporary file name even if %uSUFFIX 404 was already seen. 405 %USUFFIX 406 substitutes the last file name generated with %uSUFFIX, generating a 407 new one if there is no such last file name. In the absence of any 408 %uSUFFIX, this is just like %gSUFFIX, except they don't share 409 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s' 410 would involve the generation of two distinct file names, one 411 for each `%g.s' and another for each `%U.s'. Previously, %U was 412 simply substituted with a file name chosen for the previous %u, 413 without regard to any appended suffix. 414 %jSUFFIX 415 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is 416 writable, and if save-temps is off; otherwise, substitute the name 417 of a temporary file, just like %u. This temporary file is not 418 meant for communication between processes, but rather as a junk 419 disposal mechanism. 420 %.SUFFIX 421 substitutes .SUFFIX for the suffixes of a matched switch's args when 422 it is subsequently output with %*. SUFFIX is terminated by the next 423 space or %. 424 %d marks the argument containing or following the %d as a 425 temporary file name, so that that file will be deleted if CC exits 426 successfully. Unlike %g, this contributes no text to the argument. 427 %w marks the argument containing or following the %w as the 428 "output file" of this compilation. This puts the argument 429 into the sequence of arguments that %o will substitute later. 430 %V indicates that this compilation produces no "output file". 431 %W{...} 432 like %{...} but mark last argument supplied within 433 as a file to be deleted on failure. 434 %o substitutes the names of all the output files, with spaces 435 automatically placed around them. You should write spaces 436 around the %o as well or the results are undefined. 437 %o is for use in the specs for running the linker. 438 Input files whose names have no recognized suffix are not compiled 439 at all, but they are included among the output files, so they will 440 be linked. 441 %O substitutes the suffix for object files. Note that this is 442 handled specially when it immediately follows %g, %u, or %U 443 (with or without a suffix argument) because of the need for 444 those to form complete file names. The handling is such that 445 %O is treated exactly as if it had already been substituted, 446 except that %g, %u, and %U do not currently support additional 447 SUFFIX characters following %O as they would following, for 448 example, `.o'. 449 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot 450 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH 451 and -B options) as necessary. 452 %s current argument is the name of a library or startup file of some sort. 453 Search for that file in a standard list of directories 454 and substitute the full name found. 455 %eSTR Print STR as an error message. STR is terminated by a newline. 456 Use this when inconsistent options are detected. 457 %nSTR Print STR as a notice. STR is terminated by a newline. 458 %x{OPTION} Accumulate an option for %X. 459 %X Output the accumulated linker options specified by compilations. 460 %Y Output the accumulated assembler options specified by compilations. 461 %Z Output the accumulated preprocessor options specified by compilations. 462 %a process ASM_SPEC as a spec. 463 This allows config.h to specify part of the spec for running as. 464 %A process ASM_FINAL_SPEC as a spec. A capital A is actually 465 used here. This can be used to run a post-processor after the 466 assembler has done its job. 467 %D Dump out a -L option for each directory in startfile_prefixes. 468 If multilib_dir is set, extra entries are generated with it affixed. 469 %l process LINK_SPEC as a spec. 470 %L process LIB_SPEC as a spec. 471 %G process LIBGCC_SPEC as a spec. 472 %M output multilib_dir with directory separators replaced with "_"; 473 if multilib_dir is not set or is ".", output "". 474 %S process STARTFILE_SPEC as a spec. A capital S is actually used here. 475 %E process ENDFILE_SPEC as a spec. A capital E is actually used here. 476 %C process CPP_SPEC as a spec. 477 %1 process CC1_SPEC as a spec. 478 %2 process CC1PLUS_SPEC as a spec. 479 %* substitute the variable part of a matched option. (See below.) 480 Note that each comma in the substituted string is replaced by 481 a single space. 482 %<S remove all occurrences of -S from the command line. 483 Note - this command is position dependent. % commands in the 484 spec string before this one will see -S, % commands in the 485 spec string after this one will not. 486 %<S* remove all occurrences of all switches beginning with -S from the 487 command line. 488 %:function(args) 489 Call the named function FUNCTION, passing it ARGS. ARGS is 490 first processed as a nested spec string, then split into an 491 argument vector in the usual fashion. The function returns 492 a string which is processed as if it had appeared literally 493 as part of the current spec. 494 %{S} substitutes the -S switch, if that switch was given to CC. 495 If that switch was not specified, this substitutes nothing. 496 Here S is a metasyntactic variable. 497 %{S*} substitutes all the switches specified to CC whose names start 498 with -S. This is used for -o, -I, etc; switches that take 499 arguments. CC considers `-o foo' as being one switch whose 500 name starts with `o'. %{o*} would substitute this text, 501 including the space; thus, two arguments would be generated. 502 %{S*&T*} likewise, but preserve order of S and T options (the order 503 of S and T in the spec is not significant). Can be any number 504 of ampersand-separated variables; for each the wild card is 505 optional. Useful for CPP as %{D*&U*&A*}. 506 507 %{S:X} substitutes X, if the -S switch was given to CC. 508 %{!S:X} substitutes X, if the -S switch was NOT given to CC. 509 %{S*:X} substitutes X if one or more switches whose names start 510 with -S was given to CC. Normally X is substituted only 511 once, no matter how many such switches appeared. However, 512 if %* appears somewhere in X, then X will be substituted 513 once for each matching switch, with the %* replaced by the 514 part of that switch that matched the '*'. 515 %{.S:X} substitutes X, if processing a file with suffix S. 516 %{!.S:X} substitutes X, if NOT processing a file with suffix S. 517 518 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be 519 combined with !, ., and * as above binding stronger than the OR. 520 If %* appears in X, all of the alternatives must be starred, and 521 only the first matching alternative is substituted. 522 %{S:X; if S was given to CC, substitutes X; 523 T:Y; else if T was given to CC, substitutes Y; 524 :D} else substitutes D. There can be as many clauses as you need. 525 This may be combined with ., !, |, and * as above. 526 527 %(Spec) processes a specification defined in a specs file as *Spec: 528 %[Spec] as above, but put __ around -D arguments 529 530The conditional text X in a %{S:X} or similar construct may contain 531other nested % constructs or spaces, or even newlines. They are 532processed as usual, as described above. Trailing white space in X is 533ignored. White space may also appear anywhere on the left side of the 534colon in these constructs, except between . or * and the corresponding 535word. 536 537The -O, -f, -m, and -W switches are handled specifically in these 538constructs. If another value of -O or the negated form of a -f, -m, or 539-W switch is found later in the command line, the earlier switch 540value is ignored, except with {S*} where S is just one letter; this 541passes all matching options. 542 543The character | at the beginning of the predicate text is used to indicate 544that a command should be piped to the following command, but only if -pipe 545is specified. 546 547Note that it is built into CC which switches take arguments and which 548do not. You might think it would be useful to generalize this to 549allow each compiler's spec to say which switches take arguments. But 550this cannot be done in a consistent fashion. CC cannot even decide 551which input files have been specified without knowing which switches 552take arguments, and it must know which input files to compile in order 553to tell which compilers to run. 554 555CC also knows implicitly that arguments starting in `-l' are to be 556treated as compiler output files, and passed to the linker in their 557proper position among the other output files. */ 558 559/* Define the macros used for specs %a, %l, %L, %S, %C, %1. */ 560 561/* config.h can define ASM_SPEC to provide extra args to the assembler 562 or extra switch-translations. */ 563#ifndef ASM_SPEC 564#define ASM_SPEC "" 565#endif 566 567/* config.h can define ASM_FINAL_SPEC to run a post processor after 568 the assembler has run. */ 569#ifndef ASM_FINAL_SPEC 570#define ASM_FINAL_SPEC "" 571#endif 572 573/* config.h can define CPP_SPEC to provide extra args to the C preprocessor 574 or extra switch-translations. */ 575#ifndef CPP_SPEC 576#define CPP_SPEC "" 577#endif 578 579/* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus 580 or extra switch-translations. */ 581#ifndef CC1_SPEC 582#define CC1_SPEC "" 583#endif 584 585/* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus 586 or extra switch-translations. */ 587#ifndef CC1PLUS_SPEC 588#define CC1PLUS_SPEC "" 589#endif 590 591/* config.h can define LINK_SPEC to provide extra args to the linker 592 or extra switch-translations. */ 593#ifndef LINK_SPEC 594#define LINK_SPEC "" 595#endif 596 597/* config.h can define LIB_SPEC to override the default libraries. */ 598#ifndef LIB_SPEC 599#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}" 600#endif 601 602/* config.h can define LIBGCC_SPEC to override how and when libgcc.a is 603 included. */ 604#ifndef LIBGCC_SPEC 605#if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1) 606/* Have gcc do the search for libgcc.a. */ 607#define LIBGCC_SPEC "libgcc.a%s" 608#else 609#define LIBGCC_SPEC "-lgcc" 610#endif 611#endif 612 613/* config.h can define STARTFILE_SPEC to override the default crt0 files. */ 614#ifndef STARTFILE_SPEC 615#define STARTFILE_SPEC \ 616 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}" 617#endif 618 619/* config.h can define SWITCHES_NEED_SPACES to control which options 620 require spaces between the option and the argument. */ 621#ifndef SWITCHES_NEED_SPACES 622#define SWITCHES_NEED_SPACES "" 623#endif 624 625/* config.h can define ENDFILE_SPEC to override the default crtn files. */ 626#ifndef ENDFILE_SPEC 627#define ENDFILE_SPEC "" 628#endif 629 630#ifndef LINKER_NAME 631#define LINKER_NAME "collect2" 632#endif 633 634/* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g' 635 to the assembler. */ 636#ifndef ASM_DEBUG_SPEC 637# if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \ 638 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG) 639# define ASM_DEBUG_SPEC \ 640 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \ 641 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \ 642 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}") 643# else 644# if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG) 645# define ASM_DEBUG_SPEC "%{g*:--gstabs}" 646# endif 647# if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) 648# define ASM_DEBUG_SPEC "%{g*:--gdwarf2}" 649# endif 650# endif 651#endif 652#ifndef ASM_DEBUG_SPEC 653# define ASM_DEBUG_SPEC "" 654#endif 655 656/* Here is the spec for running the linker, after compiling all files. */ 657 658/* This is overridable by the target in case they need to specify the 659 -lgcc and -lc order specially, yet not require them to override all 660 of LINK_COMMAND_SPEC. */ 661#ifndef LINK_GCC_C_SEQUENCE_SPEC 662#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G" 663#endif 664 665#ifndef LINK_PIE_SPEC 666#ifdef HAVE_LD_PIE 667#define LINK_PIE_SPEC "%{pie:-pie} " 668#else 669#define LINK_PIE_SPEC "%{pie:} " 670#endif 671#endif 672 673/* -u* was put back because both BSD and SysV seem to support it. */ 674/* %{static:} simply prevents an error message if the target machine 675 doesn't handle -static. */ 676/* We want %{T*} after %{L*} and %D so that it can be used to specify linker 677 scripts which exist in user specified directories, or in standard 678 directories. */ 679#ifndef LINK_COMMAND_SPEC 680#define LINK_COMMAND_SPEC "\ 681%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\ 682 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\ 683 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\ 684 %{static:} %{L*} %(link_libgcc) %o %{fprofile-arcs|fprofile-generate:-lgcov}\ 685 %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\ 686 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}" 687#endif 688 689#ifndef LINK_LIBGCC_SPEC 690# ifdef LINK_LIBGCC_SPECIAL 691/* Don't generate -L options for startfile prefix list. */ 692# define LINK_LIBGCC_SPEC "" 693# else 694/* Do generate them. */ 695# define LINK_LIBGCC_SPEC "%D" 696# endif 697#endif 698 699#ifndef STARTFILE_PREFIX_SPEC 700# define STARTFILE_PREFIX_SPEC "" 701#endif 702 703#ifndef SYSROOT_SUFFIX_SPEC 704# define SYSROOT_SUFFIX_SPEC "" 705#endif 706 707#ifndef SYSROOT_HEADERS_SUFFIX_SPEC 708# define SYSROOT_HEADERS_SUFFIX_SPEC "" 709#endif 710 711static const char *asm_debug; 712static const char *cpp_spec = CPP_SPEC; 713static const char *cc1_spec = CC1_SPEC; 714static const char *cc1plus_spec = CC1PLUS_SPEC; 715static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC; 716static const char *asm_spec = ASM_SPEC; 717static const char *asm_final_spec = ASM_FINAL_SPEC; 718static const char *link_spec = LINK_SPEC; 719static const char *lib_spec = LIB_SPEC; 720static const char *libgcc_spec = LIBGCC_SPEC; 721static const char *endfile_spec = ENDFILE_SPEC; 722static const char *startfile_spec = STARTFILE_SPEC; 723static const char *switches_need_spaces = SWITCHES_NEED_SPACES; 724static const char *linker_name_spec = LINKER_NAME; 725static const char *link_command_spec = LINK_COMMAND_SPEC; 726static const char *link_libgcc_spec = LINK_LIBGCC_SPEC; 727static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC; 728static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC; 729static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC; 730 731/* Standard options to cpp, cc1, and as, to reduce duplication in specs. 732 There should be no need to override these in target dependent files, 733 but we need to copy them to the specs file so that newer versions 734 of the GCC driver can correctly drive older tool chains with the 735 appropriate -B options. */ 736 737/* When cpplib handles traditional preprocessing, get rid of this, and 738 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so 739 that we default the front end language better. */ 740static const char *trad_capable_cpp = 741"cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}"; 742 743/* We don't wrap .d files in %W{} since a missing .d file, and 744 therefore no dependency entry, confuses make into thinking a .o 745 file that happens to exist is up-to-date. */ 746static const char *cpp_unique_options = 747"%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\ 748 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\ 749 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\ 750 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\ 751 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\ 752 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\ 753 %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\ 754 %{E|M|MM:%W{o*}}"; 755 756/* This contains cpp options which are common with cc1_options and are passed 757 only when preprocessing only to avoid duplication. We pass the cc1 spec 758 options to the preprocessor so that it the cc1 spec may manipulate 759 options used to set target flags. Those special target flags settings may 760 in turn cause preprocessor symbols to be defined specially. */ 761static const char *cpp_options = 762"%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\ 763 %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\ 764 %{undef}"; 765 766/* This contains cpp options which are not passed when the preprocessor 767 output will be used by another program. */ 768static const char *cpp_debug_options = "%{d*}"; 769 770/* NB: This is shared amongst all front-ends. */ 771static const char *cc1_options = 772"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\ 773 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\ 774 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\ 775 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\ 776 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\ 777 %{Qn:-fno-ident} %{--help:--help}\ 778 %{--target-help:--target-help}\ 779 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\ 780 %{fsyntax-only:-o %j} %{-param*}"; 781 782static const char *asm_options = 783"%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}"; 784 785static const char *invoke_as = 786#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 787"%{!S:-o %|.s |\n as %(asm_options) %|.s %A }"; 788#else 789"%{!S:-o %|.s |\n as %(asm_options) %m.s %A }"; 790#endif 791 792/* Some compilers have limits on line lengths, and the multilib_select 793 and/or multilib_matches strings can be very long, so we build them at 794 run time. */ 795static struct obstack multilib_obstack; 796static const char *multilib_select; 797static const char *multilib_matches; 798static const char *multilib_defaults; 799static const char *multilib_exclusions; 800 801/* Check whether a particular argument is a default argument. */ 802 803#ifndef MULTILIB_DEFAULTS 804#define MULTILIB_DEFAULTS { "" } 805#endif 806 807static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS; 808 809#ifndef DRIVER_SELF_SPECS 810#define DRIVER_SELF_SPECS "" 811#endif 812 813static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS }; 814 815#ifndef OPTION_DEFAULT_SPECS 816#define OPTION_DEFAULT_SPECS { "", "" } 817#endif 818 819struct default_spec 820{ 821 const char *name; 822 const char *spec; 823}; 824 825static const struct default_spec 826 option_default_specs[] = { OPTION_DEFAULT_SPECS }; 827 828struct user_specs 829{ 830 struct user_specs *next; 831 const char *filename; 832}; 833 834static struct user_specs *user_specs_head, *user_specs_tail; 835 836#ifndef SWITCH_TAKES_ARG 837#define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR) 838#endif 839 840#ifndef WORD_SWITCH_TAKES_ARG 841#define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR) 842#endif 843 844#ifdef HAVE_TARGET_EXECUTABLE_SUFFIX 845/* This defines which switches stop a full compilation. */ 846#define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \ 847 ((CHAR) == 'c' || (CHAR) == 'S') 848 849#ifndef SWITCH_CURTAILS_COMPILATION 850#define SWITCH_CURTAILS_COMPILATION(CHAR) \ 851 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) 852#endif 853#endif 854 855/* Record the mapping from file suffixes for compilation specs. */ 856 857struct compiler 858{ 859 const char *suffix; /* Use this compiler for input files 860 whose names end in this suffix. */ 861 862 const char *spec; /* To use this compiler, run this spec. */ 863 864 const char *cpp_spec; /* If non-NULL, substitute this spec 865 for `%C', rather than the usual 866 cpp_spec. */ 867}; 868 869/* Pointer to a vector of `struct compiler' that gives the spec for 870 compiling a file, based on its suffix. 871 A file that does not end in any of these suffixes will be passed 872 unchanged to the loader and nothing else will be done to it. 873 874 An entry containing two 0s is used to terminate the vector. 875 876 If multiple entries match a file, the last matching one is used. */ 877 878static struct compiler *compilers; 879 880/* Number of entries in `compilers', not counting the null terminator. */ 881 882static int n_compilers; 883 884/* The default list of file name suffixes and their compilation specs. */ 885 886static const struct compiler default_compilers[] = 887{ 888 /* Add lists of suffixes of known languages here. If those languages 889 were not present when we built the driver, we will hit these copies 890 and be given a more meaningful error than "file not used since 891 linking is not done". */ 892 {".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0}, 893 {".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0}, 894 {".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0}, 895 {".CPP", "#C++", 0}, {".ii", "#C++", 0}, 896 {".ads", "#Ada", 0}, {".adb", "#Ada", 0}, 897 {".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0}, 898 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0}, 899 {".r", "#Ratfor", 0}, 900 {".p", "#Pascal", 0}, {".pas", "#Pascal", 0}, 901 {".java", "#Java", 0}, {".class", "#Java", 0}, 902 {".zip", "#Java", 0}, {".jar", "#Java", 0}, 903 /* Next come the entries for C. */ 904 {".c", "@c", 0}, 905 {"@c", 906 /* cc1 has an integrated ISO C preprocessor. We should invoke the 907 external preprocessor if -save-temps is given. */ 908 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 909 %{!E:%{!M:%{!MM:\ 910 %{traditional|ftraditional:\ 911%eGNU C no longer supports -traditional without -E}\ 912 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 913 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\ 914 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \ 915 %(cc1_options)}\ 916 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\ 917 cc1 %(cpp_unique_options) %(cc1_options)}}}\ 918 %{!fsyntax-only:%(invoke_as)}}}}", 0}, 919 {"-", 920 "%{!E:%e-E or -x required when input is from standard input}\ 921 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0}, 922 {".h", "@c-header", 0}, 923 {"@c-header", 924 /* cc1 has an integrated ISO C preprocessor. We should invoke the 925 external preprocessor if -save-temps is given. */ 926 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 927 %{!E:%{!M:%{!MM:\ 928 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 929 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\ 930 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \ 931 %(cc1_options)\ 932 -o %g.s %{!o*:--output-pch=%i.gch}\ 933 %W{o*:--output-pch=%*}%V}\ 934 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\ 935 cc1 %(cpp_unique_options) %(cc1_options)\ 936 -o %g.s %{!o*:--output-pch=%i.gch}\ 937 %W{o*:--output-pch=%*}%V}}}}}}", 0}, 938 {".i", "@cpp-output", 0}, 939 {"@cpp-output", 940 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0}, 941 {".s", "@assembler", 0}, 942 {"@assembler", 943 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0}, 944 {".S", "@assembler-with-cpp", 0}, 945 {"@assembler-with-cpp", 946#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 947 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 948 %{E|M|MM:%(cpp_debug_options)}\ 949 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 950 as %(asm_debug) %(asm_options) %|.s %A }}}}" 951#else 952 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 953 %{E|M|MM:%(cpp_debug_options)}\ 954 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 955 as %(asm_debug) %(asm_options) %m.s %A }}}}" 956#endif 957 , 0}, 958 959#include "specs.h" 960 /* Mark end of table. */ 961 {0, 0, 0} 962}; 963 964/* Number of elements in default_compilers, not counting the terminator. */ 965 966static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1; 967 968/* A vector of options to give to the linker. 969 These options are accumulated by %x, 970 and substituted into the linker command with %X. */ 971static int n_linker_options; 972static char **linker_options; 973 974/* A vector of options to give to the assembler. 975 These options are accumulated by -Wa, 976 and substituted into the assembler command with %Y. */ 977static int n_assembler_options; 978static char **assembler_options; 979 980/* A vector of options to give to the preprocessor. 981 These options are accumulated by -Wp, 982 and substituted into the preprocessor command with %Z. */ 983static int n_preprocessor_options; 984static char **preprocessor_options; 985 986/* Define how to map long options into short ones. */ 987 988/* This structure describes one mapping. */ 989struct option_map 990{ 991 /* The long option's name. */ 992 const char *const name; 993 /* The equivalent short option. */ 994 const char *const equivalent; 995 /* Argument info. A string of flag chars; NULL equals no options. 996 a => argument required. 997 o => argument optional. 998 j => join argument to equivalent, making one word. 999 * => require other text after NAME as an argument. */ 1000 const char *const arg_info; 1001}; 1002 1003/* This is the table of mappings. Mappings are tried sequentially 1004 for each option encountered; the first one that matches, wins. */ 1005 1006static const struct option_map option_map[] = 1007 { 1008 {"--all-warnings", "-Wall", 0}, 1009 {"--ansi", "-ansi", 0}, 1010 {"--assemble", "-S", 0}, 1011 {"--assert", "-A", "a"}, 1012 {"--classpath", "-fclasspath=", "aj"}, 1013 {"--bootclasspath", "-fbootclasspath=", "aj"}, 1014 {"--CLASSPATH", "-fclasspath=", "aj"}, 1015 {"--comments", "-C", 0}, 1016 {"--comments-in-macros", "-CC", 0}, 1017 {"--compile", "-c", 0}, 1018 {"--debug", "-g", "oj"}, 1019 {"--define-macro", "-D", "aj"}, 1020 {"--dependencies", "-M", 0}, 1021 {"--dump", "-d", "a"}, 1022 {"--dumpbase", "-dumpbase", "a"}, 1023 {"--entry", "-e", 0}, 1024 {"--extra-warnings", "-W", 0}, 1025 {"--for-assembler", "-Wa", "a"}, 1026 {"--for-linker", "-Xlinker", "a"}, 1027 {"--force-link", "-u", "a"}, 1028 {"--imacros", "-imacros", "a"}, 1029 {"--include", "-include", "a"}, 1030 {"--include-barrier", "-I-", 0}, 1031 {"--include-directory", "-I", "aj"}, 1032 {"--include-directory-after", "-idirafter", "a"}, 1033 {"--include-prefix", "-iprefix", "a"}, 1034 {"--include-with-prefix", "-iwithprefix", "a"}, 1035 {"--include-with-prefix-before", "-iwithprefixbefore", "a"}, 1036 {"--include-with-prefix-after", "-iwithprefix", "a"}, 1037 {"--language", "-x", "a"}, 1038 {"--library-directory", "-L", "a"}, 1039 {"--machine", "-m", "aj"}, 1040 {"--machine-", "-m", "*j"}, 1041 {"--no-integrated-cpp", "-no-integrated-cpp", 0}, 1042 {"--no-line-commands", "-P", 0}, 1043 {"--no-precompiled-includes", "-noprecomp", 0}, 1044 {"--no-standard-includes", "-nostdinc", 0}, 1045 {"--no-standard-libraries", "-nostdlib", 0}, 1046 {"--no-warnings", "-w", 0}, 1047 {"--optimize", "-O", "oj"}, 1048 {"--output", "-o", "a"}, 1049 {"--output-class-directory", "-foutput-class-dir=", "ja"}, 1050 {"--param", "--param", "a"}, 1051 {"--pedantic", "-pedantic", 0}, 1052 {"--pedantic-errors", "-pedantic-errors", 0}, 1053 {"--pie", "-pie", 0}, 1054 {"--pipe", "-pipe", 0}, 1055 {"--prefix", "-B", "a"}, 1056 {"--preprocess", "-E", 0}, 1057 {"--print-search-dirs", "-print-search-dirs", 0}, 1058 {"--print-file-name", "-print-file-name=", "aj"}, 1059 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0}, 1060 {"--print-missing-file-dependencies", "-MG", 0}, 1061 {"--print-multi-lib", "-print-multi-lib", 0}, 1062 {"--print-multi-directory", "-print-multi-directory", 0}, 1063 {"--print-multi-os-directory", "-print-multi-os-directory", 0}, 1064 {"--print-prog-name", "-print-prog-name=", "aj"}, 1065 {"--profile", "-p", 0}, 1066 {"--profile-blocks", "-a", 0}, 1067 {"--quiet", "-q", 0}, 1068 {"--resource", "-fcompile-resource=", "aj"}, 1069 {"--save-temps", "-save-temps", 0}, 1070 {"--shared", "-shared", 0}, 1071 {"--silent", "-q", 0}, 1072 {"--specs", "-specs=", "aj"}, 1073 {"--static", "-static", 0}, 1074 {"--std", "-std=", "aj"}, 1075 {"--symbolic", "-symbolic", 0}, 1076 {"--time", "-time", 0}, 1077 {"--trace-includes", "-H", 0}, 1078 {"--traditional", "-traditional", 0}, 1079 {"--traditional-cpp", "-traditional-cpp", 0}, 1080 {"--trigraphs", "-trigraphs", 0}, 1081 {"--undefine-macro", "-U", "aj"}, 1082 {"--user-dependencies", "-MM", 0}, 1083 {"--verbose", "-v", 0}, 1084 {"--warn-", "-W", "*j"}, 1085 {"--write-dependencies", "-MD", 0}, 1086 {"--write-user-dependencies", "-MMD", 0}, 1087 {"--", "-f", "*j"} 1088 }; 1089 1090 1091#ifdef TARGET_OPTION_TRANSLATE_TABLE 1092static const struct { 1093 const char *const option_found; 1094 const char *const replacements; 1095} target_option_translations[] = 1096{ 1097 TARGET_OPTION_TRANSLATE_TABLE, 1098 { 0, 0 } 1099}; 1100#endif 1101 1102/* Translate the options described by *ARGCP and *ARGVP. 1103 Make a new vector and store it back in *ARGVP, 1104 and store its length in *ARGVC. */ 1105 1106static void 1107translate_options (int *argcp, const char *const **argvp) 1108{ 1109 int i; 1110 int argc = *argcp; 1111 const char *const *argv = *argvp; 1112 int newvsize = (argc + 2) * 2 * sizeof (const char *); 1113 const char **newv = xmalloc (newvsize); 1114 int newindex = 0; 1115 1116 i = 0; 1117 newv[newindex++] = argv[i++]; 1118 1119 while (i < argc) 1120 { 1121#ifdef TARGET_OPTION_TRANSLATE_TABLE 1122 int tott_idx; 1123 1124 for (tott_idx = 0; 1125 target_option_translations[tott_idx].option_found; 1126 tott_idx++) 1127 { 1128 if (strcmp (target_option_translations[tott_idx].option_found, 1129 argv[i]) == 0) 1130 { 1131 int spaces = 1; 1132 const char *sp; 1133 char *np; 1134 1135 for (sp = target_option_translations[tott_idx].replacements; 1136 *sp; sp++) 1137 { 1138 if (*sp == ' ') 1139 spaces ++; 1140 } 1141 1142 newvsize += spaces * sizeof (const char *); 1143 newv = xrealloc (newv, newvsize); 1144 1145 sp = target_option_translations[tott_idx].replacements; 1146 np = xstrdup (sp); 1147 1148 while (1) 1149 { 1150 while (*np == ' ') 1151 np++; 1152 if (*np == 0) 1153 break; 1154 newv[newindex++] = np; 1155 while (*np != ' ' && *np) 1156 np++; 1157 if (*np == 0) 1158 break; 1159 *np++ = 0; 1160 } 1161 1162 i ++; 1163 break; 1164 } 1165 } 1166 if (target_option_translations[tott_idx].option_found) 1167 continue; 1168#endif 1169 1170 /* Translate -- options. */ 1171 if (argv[i][0] == '-' && argv[i][1] == '-') 1172 { 1173 size_t j; 1174 /* Find a mapping that applies to this option. */ 1175 for (j = 0; j < ARRAY_SIZE (option_map); j++) 1176 { 1177 size_t optlen = strlen (option_map[j].name); 1178 size_t arglen = strlen (argv[i]); 1179 size_t complen = arglen > optlen ? optlen : arglen; 1180 const char *arginfo = option_map[j].arg_info; 1181 1182 if (arginfo == 0) 1183 arginfo = ""; 1184 1185 if (!strncmp (argv[i], option_map[j].name, complen)) 1186 { 1187 const char *arg = 0; 1188 1189 if (arglen < optlen) 1190 { 1191 size_t k; 1192 for (k = j + 1; k < ARRAY_SIZE (option_map); k++) 1193 if (strlen (option_map[k].name) >= arglen 1194 && !strncmp (argv[i], option_map[k].name, arglen)) 1195 { 1196 error ("ambiguous abbreviation %s", argv[i]); 1197 break; 1198 } 1199 1200 if (k != ARRAY_SIZE (option_map)) 1201 break; 1202 } 1203 1204 if (arglen > optlen) 1205 { 1206 /* If the option has an argument, accept that. */ 1207 if (argv[i][optlen] == '=') 1208 arg = argv[i] + optlen + 1; 1209 1210 /* If this mapping requires extra text at end of name, 1211 accept that as "argument". */ 1212 else if (strchr (arginfo, '*') != 0) 1213 arg = argv[i] + optlen; 1214 1215 /* Otherwise, extra text at end means mismatch. 1216 Try other mappings. */ 1217 else 1218 continue; 1219 } 1220 1221 else if (strchr (arginfo, '*') != 0) 1222 { 1223 error ("incomplete `%s' option", option_map[j].name); 1224 break; 1225 } 1226 1227 /* Handle arguments. */ 1228 if (strchr (arginfo, 'a') != 0) 1229 { 1230 if (arg == 0) 1231 { 1232 if (i + 1 == argc) 1233 { 1234 error ("missing argument to `%s' option", 1235 option_map[j].name); 1236 break; 1237 } 1238 1239 arg = argv[++i]; 1240 } 1241 } 1242 else if (strchr (arginfo, '*') != 0) 1243 ; 1244 else if (strchr (arginfo, 'o') == 0) 1245 { 1246 if (arg != 0) 1247 error ("extraneous argument to `%s' option", 1248 option_map[j].name); 1249 arg = 0; 1250 } 1251 1252 /* Store the translation as one argv elt or as two. */ 1253 if (arg != 0 && strchr (arginfo, 'j') != 0) 1254 newv[newindex++] = concat (option_map[j].equivalent, arg, 1255 NULL); 1256 else if (arg != 0) 1257 { 1258 newv[newindex++] = option_map[j].equivalent; 1259 newv[newindex++] = arg; 1260 } 1261 else 1262 newv[newindex++] = option_map[j].equivalent; 1263 1264 break; 1265 } 1266 } 1267 i++; 1268 } 1269 1270 /* Handle old-fashioned options--just copy them through, 1271 with their arguments. */ 1272 else if (argv[i][0] == '-') 1273 { 1274 const char *p = argv[i] + 1; 1275 int c = *p; 1276 int nskip = 1; 1277 1278 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 1279 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0); 1280 else if (WORD_SWITCH_TAKES_ARG (p)) 1281 nskip += WORD_SWITCH_TAKES_ARG (p); 1282 else if ((c == 'B' || c == 'b' || c == 'x') 1283 && p[1] == 0) 1284 nskip += 1; 1285 else if (! strcmp (p, "Xlinker")) 1286 nskip += 1; 1287 else if (! strcmp (p, "Xpreprocessor")) 1288 nskip += 1; 1289 else if (! strcmp (p, "Xassembler")) 1290 nskip += 1; 1291 1292 /* Watch out for an option at the end of the command line that 1293 is missing arguments, and avoid skipping past the end of the 1294 command line. */ 1295 if (nskip + i > argc) 1296 nskip = argc - i; 1297 1298 while (nskip > 0) 1299 { 1300 newv[newindex++] = argv[i++]; 1301 nskip--; 1302 } 1303 } 1304 else 1305 /* Ordinary operands, or +e options. */ 1306 newv[newindex++] = argv[i++]; 1307 } 1308 1309 newv[newindex] = 0; 1310 1311 *argvp = newv; 1312 *argcp = newindex; 1313} 1314 1315static char * 1316skip_whitespace (char *p) 1317{ 1318 while (1) 1319 { 1320 /* A fully-blank line is a delimiter in the SPEC file and shouldn't 1321 be considered whitespace. */ 1322 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n') 1323 return p + 1; 1324 else if (*p == '\n' || *p == ' ' || *p == '\t') 1325 p++; 1326 else if (*p == '#') 1327 { 1328 while (*p != '\n') 1329 p++; 1330 p++; 1331 } 1332 else 1333 break; 1334 } 1335 1336 return p; 1337} 1338/* Structures to keep track of prefixes to try when looking for files. */ 1339 1340struct prefix_list 1341{ 1342 const char *prefix; /* String to prepend to the path. */ 1343 struct prefix_list *next; /* Next in linked list. */ 1344 int require_machine_suffix; /* Don't use without machine_suffix. */ 1345 /* 2 means try both machine_suffix and just_machine_suffix. */ 1346 int *used_flag_ptr; /* 1 if a file was found with this prefix. */ 1347 int priority; /* Sort key - priority within list. */ 1348 int os_multilib; /* 1 if OS multilib scheme should be used, 1349 0 for GCC multilib scheme. */ 1350}; 1351 1352struct path_prefix 1353{ 1354 struct prefix_list *plist; /* List of prefixes to try */ 1355 int max_len; /* Max length of a prefix in PLIST */ 1356 const char *name; /* Name of this list (used in config stuff) */ 1357}; 1358 1359/* List of prefixes to try when looking for executables. */ 1360 1361static struct path_prefix exec_prefixes = { 0, 0, "exec" }; 1362 1363/* List of prefixes to try when looking for startup (crt0) files. */ 1364 1365static struct path_prefix startfile_prefixes = { 0, 0, "startfile" }; 1366 1367/* List of prefixes to try when looking for include files. */ 1368 1369static struct path_prefix include_prefixes = { 0, 0, "include" }; 1370 1371/* Suffix to attach to directories searched for commands. 1372 This looks like `MACHINE/VERSION/'. */ 1373 1374static const char *machine_suffix = 0; 1375 1376/* Suffix to attach to directories searched for commands. 1377 This is just `MACHINE/'. */ 1378 1379static const char *just_machine_suffix = 0; 1380 1381/* Adjusted value of GCC_EXEC_PREFIX envvar. */ 1382 1383static const char *gcc_exec_prefix; 1384 1385/* Adjusted value of standard_libexec_prefix. */ 1386 1387static const char *gcc_libexec_prefix; 1388 1389/* Default prefixes to attach to command names. */ 1390 1391#ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */ 1392#undef MD_EXEC_PREFIX 1393#undef MD_STARTFILE_PREFIX 1394#undef MD_STARTFILE_PREFIX_1 1395#endif 1396 1397/* If no prefixes defined, use the null string, which will disable them. */ 1398#ifndef MD_EXEC_PREFIX 1399#define MD_EXEC_PREFIX "" 1400#endif 1401#ifndef MD_STARTFILE_PREFIX 1402#define MD_STARTFILE_PREFIX "" 1403#endif 1404#ifndef MD_STARTFILE_PREFIX_1 1405#define MD_STARTFILE_PREFIX_1 "" 1406#endif 1407 1408static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX; 1409static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/"; 1410static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/"; 1411static const char *md_exec_prefix = MD_EXEC_PREFIX; 1412 1413static const char *md_startfile_prefix = MD_STARTFILE_PREFIX; 1414static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1; 1415static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; 1416static const char *const standard_startfile_prefix_1 = "/lib/"; 1417static const char *const standard_startfile_prefix_2 = "/usr/lib/"; 1418 1419static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX; 1420static const char *tooldir_prefix; 1421 1422#ifndef FREEBSD_NATIVE 1423static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX; 1424#endif /* not FREEBSD_NATIVE */ 1425 1426static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX; 1427 1428/* Subdirectory to use for locating libraries. Set by 1429 set_multilib_dir based on the compilation options. */ 1430 1431static const char *multilib_dir; 1432 1433/* Subdirectory to use for locating libraries in OS conventions. Set by 1434 set_multilib_dir based on the compilation options. */ 1435 1436static const char *multilib_os_dir; 1437 1438/* Structure to keep track of the specs that have been defined so far. 1439 These are accessed using %(specname) or %[specname] in a compiler 1440 or link spec. */ 1441 1442struct spec_list 1443{ 1444 /* The following 2 fields must be first */ 1445 /* to allow EXTRA_SPECS to be initialized */ 1446 const char *name; /* name of the spec. */ 1447 const char *ptr; /* available ptr if no static pointer */ 1448 1449 /* The following fields are not initialized */ 1450 /* by EXTRA_SPECS */ 1451 const char **ptr_spec; /* pointer to the spec itself. */ 1452 struct spec_list *next; /* Next spec in linked list. */ 1453 int name_len; /* length of the name */ 1454 int alloc_p; /* whether string was allocated */ 1455}; 1456 1457#define INIT_STATIC_SPEC(NAME,PTR) \ 1458{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 } 1459 1460/* List of statically defined specs. */ 1461static struct spec_list static_specs[] = 1462{ 1463 INIT_STATIC_SPEC ("asm", &asm_spec), 1464 INIT_STATIC_SPEC ("asm_debug", &asm_debug), 1465 INIT_STATIC_SPEC ("asm_final", &asm_final_spec), 1466 INIT_STATIC_SPEC ("asm_options", &asm_options), 1467 INIT_STATIC_SPEC ("invoke_as", &invoke_as), 1468 INIT_STATIC_SPEC ("cpp", &cpp_spec), 1469 INIT_STATIC_SPEC ("cpp_options", &cpp_options), 1470 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options), 1471 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options), 1472 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp), 1473 INIT_STATIC_SPEC ("cc1", &cc1_spec), 1474 INIT_STATIC_SPEC ("cc1_options", &cc1_options), 1475 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec), 1476 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec), 1477 INIT_STATIC_SPEC ("endfile", &endfile_spec), 1478 INIT_STATIC_SPEC ("link", &link_spec), 1479 INIT_STATIC_SPEC ("lib", &lib_spec), 1480 INIT_STATIC_SPEC ("libgcc", &libgcc_spec), 1481 INIT_STATIC_SPEC ("startfile", &startfile_spec), 1482 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces), 1483 INIT_STATIC_SPEC ("cross_compile", &cross_compile), 1484 INIT_STATIC_SPEC ("version", &compiler_version), 1485 INIT_STATIC_SPEC ("multilib", &multilib_select), 1486 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults), 1487 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra), 1488 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches), 1489 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions), 1490 INIT_STATIC_SPEC ("multilib_options", &multilib_options), 1491 INIT_STATIC_SPEC ("linker", &linker_name_spec), 1492 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec), 1493 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix), 1494 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix), 1495 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1), 1496 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec), 1497 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec), 1498 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec), 1499}; 1500 1501#ifdef EXTRA_SPECS /* additional specs needed */ 1502/* Structure to keep track of just the first two args of a spec_list. 1503 That is all that the EXTRA_SPECS macro gives us. */ 1504struct spec_list_1 1505{ 1506 const char *const name; 1507 const char *const ptr; 1508}; 1509 1510static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS }; 1511static struct spec_list *extra_specs = (struct spec_list *) 0; 1512#endif 1513 1514/* List of dynamically allocates specs that have been defined so far. */ 1515 1516static struct spec_list *specs = (struct spec_list *) 0; 1517 1518/* List of static spec functions. */ 1519 1520static const struct spec_function static_spec_functions[] = 1521{ 1522 { "if-exists", if_exists_spec_function }, 1523 { "if-exists-else", if_exists_else_spec_function }, 1524 { 0, 0 } 1525}; 1526 1527static int processing_spec_function; 1528 1529/* Add appropriate libgcc specs to OBSTACK, taking into account 1530 various permutations of -shared-libgcc, -shared, and such. */ 1531 1532#ifdef ENABLE_SHARED_LIBGCC 1533static void 1534init_gcc_specs (struct obstack *obstack, const char *shared_name, 1535 const char *static_name, const char *eh_name) 1536{ 1537 char *buf; 1538 1539 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, 1540 "}%{!static:%{!static-libgcc:", 1541#ifdef HAVE_LD_AS_NEEDED 1542 "%{!shared-libgcc:", static_name, 1543 " --as-needed ", shared_name, " --no-as-needed}" 1544 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name, 1545 "}", 1546#else 1547 "%{!shared:%{!shared-libgcc:", static_name, " ", 1548 eh_name, "}%{shared-libgcc:", shared_name, " ", 1549 static_name, "}}%{shared:", 1550#ifdef LINK_EH_SPEC 1551 "%{shared-libgcc:", shared_name, 1552 "}%{!shared-libgcc:", static_name, "}", 1553#else 1554 shared_name, 1555#endif 1556#endif 1557 "}}}", NULL); 1558 1559 obstack_grow (obstack, buf, strlen (buf)); 1560 free (buf); 1561} 1562#endif /* ENABLE_SHARED_LIBGCC */ 1563 1564/* Initialize the specs lookup routines. */ 1565 1566static void 1567init_spec (void) 1568{ 1569 struct spec_list *next = (struct spec_list *) 0; 1570 struct spec_list *sl = (struct spec_list *) 0; 1571 int i; 1572 1573 if (specs) 1574 return; /* Already initialized. */ 1575 1576 if (verbose_flag) 1577 notice ("Using built-in specs.\n"); 1578 1579#ifdef EXTRA_SPECS 1580 extra_specs = xcalloc (sizeof (struct spec_list), 1581 ARRAY_SIZE (extra_specs_1)); 1582 1583 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--) 1584 { 1585 sl = &extra_specs[i]; 1586 sl->name = extra_specs_1[i].name; 1587 sl->ptr = extra_specs_1[i].ptr; 1588 sl->next = next; 1589 sl->name_len = strlen (sl->name); 1590 sl->ptr_spec = &sl->ptr; 1591 next = sl; 1592 } 1593#endif 1594 1595 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes 1596 on ?: in file-scope variable initializations. */ 1597 asm_debug = ASM_DEBUG_SPEC; 1598 1599 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1600 { 1601 sl = &static_specs[i]; 1602 sl->next = next; 1603 next = sl; 1604 } 1605 1606#ifdef ENABLE_SHARED_LIBGCC 1607 /* ??? If neither -shared-libgcc nor --static-libgcc was 1608 seen, then we should be making an educated guess. Some proposed 1609 heuristics for ELF include: 1610 1611 (1) If "-Wl,--export-dynamic", then it's a fair bet that the 1612 program will be doing dynamic loading, which will likely 1613 need the shared libgcc. 1614 1615 (2) If "-ldl", then it's also a fair bet that we're doing 1616 dynamic loading. 1617 1618 (3) For each ET_DYN we're linking against (either through -lfoo 1619 or /some/path/foo.so), check to see whether it or one of 1620 its dependencies depends on a shared libgcc. 1621 1622 (4) If "-shared" 1623 1624 If the runtime is fixed to look for program headers instead 1625 of calling __register_frame_info at all, for each object, 1626 use the shared libgcc if any EH symbol referenced. 1627 1628 If crtstuff is fixed to not invoke __register_frame_info 1629 automatically, for each object, use the shared libgcc if 1630 any non-empty unwind section found. 1631 1632 Doing any of this probably requires invoking an external program to 1633 do the actual object file scanning. */ 1634 { 1635 const char *p = libgcc_spec; 1636 int in_sep = 1; 1637 1638 /* Transform the extant libgcc_spec into one that uses the shared libgcc 1639 when given the proper command line arguments. */ 1640 while (*p) 1641 { 1642 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0) 1643 { 1644 init_gcc_specs (&obstack, 1645#ifdef NO_SHARED_LIBGCC_MULTILIB 1646 "-lgcc_s" 1647#else 1648 "-lgcc_s%M" 1649#endif 1650#ifdef USE_LIBUNWIND_EXCEPTIONS 1651 " -lunwind" 1652#endif 1653 , 1654 "-lgcc", 1655 "-lgcc_eh" 1656#ifdef USE_LIBUNWIND_EXCEPTIONS 1657# ifdef HAVE_LD_STATIC_DYNAMIC 1658 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}" 1659# else 1660 " -lunwind" 1661# endif 1662#endif 1663 ); 1664 1665 p += 5; 1666 in_sep = 0; 1667 } 1668 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0) 1669 { 1670 /* Ug. We don't know shared library extensions. Hope that 1671 systems that use this form don't do shared libraries. */ 1672 init_gcc_specs (&obstack, 1673#ifdef NO_SHARED_LIBGCC_MULTILIB 1674 "-lgcc_s" 1675#else 1676 "-lgcc_s%M" 1677#endif 1678 , 1679 "libgcc.a%s", 1680 "libgcc_eh.a%s" 1681#ifdef USE_LIBUNWIND_EXCEPTIONS 1682 " -lunwind" 1683#endif 1684 ); 1685 p += 10; 1686 in_sep = 0; 1687 } 1688 else 1689 { 1690 obstack_1grow (&obstack, *p); 1691 in_sep = (*p == ' '); 1692 p += 1; 1693 } 1694 } 1695 1696 obstack_1grow (&obstack, '\0'); 1697 libgcc_spec = obstack_finish (&obstack); 1698 } 1699#endif 1700#ifdef USE_AS_TRADITIONAL_FORMAT 1701 /* Prepend "--traditional-format" to whatever asm_spec we had before. */ 1702 { 1703 static const char tf[] = "--traditional-format "; 1704 obstack_grow (&obstack, tf, sizeof(tf) - 1); 1705 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec)); 1706 asm_spec = obstack_finish (&obstack); 1707 } 1708#endif 1709#ifdef LINK_EH_SPEC 1710 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */ 1711 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1); 1712 obstack_grow0 (&obstack, link_spec, strlen (link_spec)); 1713 link_spec = obstack_finish (&obstack); 1714#endif 1715 1716 specs = sl; 1717} 1718 1719/* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is 1720 removed; If the spec starts with a + then SPEC is added to the end of the 1721 current spec. */ 1722 1723static void 1724set_spec (const char *name, const char *spec) 1725{ 1726 struct spec_list *sl; 1727 const char *old_spec; 1728 int name_len = strlen (name); 1729 int i; 1730 1731 /* If this is the first call, initialize the statically allocated specs. */ 1732 if (!specs) 1733 { 1734 struct spec_list *next = (struct spec_list *) 0; 1735 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1736 { 1737 sl = &static_specs[i]; 1738 sl->next = next; 1739 next = sl; 1740 } 1741 specs = sl; 1742 } 1743 1744 /* See if the spec already exists. */ 1745 for (sl = specs; sl; sl = sl->next) 1746 if (name_len == sl->name_len && !strcmp (sl->name, name)) 1747 break; 1748 1749 if (!sl) 1750 { 1751 /* Not found - make it. */ 1752 sl = xmalloc (sizeof (struct spec_list)); 1753 sl->name = xstrdup (name); 1754 sl->name_len = name_len; 1755 sl->ptr_spec = &sl->ptr; 1756 sl->alloc_p = 0; 1757 *(sl->ptr_spec) = ""; 1758 sl->next = specs; 1759 specs = sl; 1760 } 1761 1762 old_spec = *(sl->ptr_spec); 1763 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1])) 1764 ? concat (old_spec, spec + 1, NULL) 1765 : xstrdup (spec)); 1766 1767#ifdef DEBUG_SPECS 1768 if (verbose_flag) 1769 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec)); 1770#endif 1771 1772 /* Free the old spec. */ 1773 if (old_spec && sl->alloc_p) 1774 free ((void *) old_spec); 1775 1776 sl->alloc_p = 1; 1777} 1778 1779/* Accumulate a command (program name and args), and run it. */ 1780 1781/* Vector of pointers to arguments in the current line of specifications. */ 1782 1783static const char **argbuf; 1784 1785/* Number of elements allocated in argbuf. */ 1786 1787static int argbuf_length; 1788 1789/* Number of elements in argbuf currently in use (containing args). */ 1790 1791static int argbuf_index; 1792 1793/* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated 1794 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for 1795 it here. */ 1796 1797static struct temp_name { 1798 const char *suffix; /* suffix associated with the code. */ 1799 int length; /* strlen (suffix). */ 1800 int unique; /* Indicates whether %g or %u/%U was used. */ 1801 const char *filename; /* associated filename. */ 1802 int filename_length; /* strlen (filename). */ 1803 struct temp_name *next; 1804} *temp_names; 1805 1806/* Number of commands executed so far. */ 1807 1808static int execution_count; 1809 1810/* Number of commands that exited with a signal. */ 1811 1812static int signal_count; 1813 1814/* Name with which this program was invoked. */ 1815 1816static const char *programname; 1817 1818/* Allocate the argument vector. */ 1819 1820static void 1821alloc_args (void) 1822{ 1823 argbuf_length = 10; 1824 argbuf = xmalloc (argbuf_length * sizeof (const char *)); 1825} 1826 1827/* Clear out the vector of arguments (after a command is executed). */ 1828 1829static void 1830clear_args (void) 1831{ 1832 argbuf_index = 0; 1833} 1834 1835/* Add one argument to the vector at the end. 1836 This is done when a space is seen or at the end of the line. 1837 If DELETE_ALWAYS is nonzero, the arg is a filename 1838 and the file should be deleted eventually. 1839 If DELETE_FAILURE is nonzero, the arg is a filename 1840 and the file should be deleted if this compilation fails. */ 1841 1842static void 1843store_arg (const char *arg, int delete_always, int delete_failure) 1844{ 1845 if (argbuf_index + 1 == argbuf_length) 1846 argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *)); 1847 1848 argbuf[argbuf_index++] = arg; 1849 argbuf[argbuf_index] = 0; 1850 1851 if (delete_always || delete_failure) 1852 record_temp_file (arg, delete_always, delete_failure); 1853} 1854 1855/* Load specs from a file name named FILENAME, replacing occurrences of 1856 various different types of line-endings, \r\n, \n\r and just \r, with 1857 a single \n. */ 1858 1859static char * 1860load_specs (const char *filename) 1861{ 1862 int desc; 1863 int readlen; 1864 struct stat statbuf; 1865 char *buffer; 1866 char *buffer_p; 1867 char *specs; 1868 char *specs_p; 1869 1870 if (verbose_flag) 1871 notice ("Reading specs from %s\n", filename); 1872 1873 /* Open and stat the file. */ 1874 desc = open (filename, O_RDONLY, 0); 1875 if (desc < 0) 1876 pfatal_with_name (filename); 1877 if (stat (filename, &statbuf) < 0) 1878 pfatal_with_name (filename); 1879 1880 /* Read contents of file into BUFFER. */ 1881 buffer = xmalloc ((unsigned) statbuf.st_size + 1); 1882 readlen = read (desc, buffer, (unsigned) statbuf.st_size); 1883 if (readlen < 0) 1884 pfatal_with_name (filename); 1885 buffer[readlen] = 0; 1886 close (desc); 1887 1888 specs = xmalloc (readlen + 1); 1889 specs_p = specs; 1890 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++) 1891 { 1892 int skip = 0; 1893 char c = *buffer_p; 1894 if (c == '\r') 1895 { 1896 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */ 1897 skip = 1; 1898 else if (*(buffer_p + 1) == '\n') /* \r\n */ 1899 skip = 1; 1900 else /* \r */ 1901 c = '\n'; 1902 } 1903 if (! skip) 1904 *specs_p++ = c; 1905 } 1906 *specs_p = '\0'; 1907 1908 free (buffer); 1909 return (specs); 1910} 1911 1912/* Read compilation specs from a file named FILENAME, 1913 replacing the default ones. 1914 1915 A suffix which starts with `*' is a definition for 1916 one of the machine-specific sub-specs. The "suffix" should be 1917 *asm, *cc1, *cpp, *link, *startfile, etc. 1918 The corresponding spec is stored in asm_spec, etc., 1919 rather than in the `compilers' vector. 1920 1921 Anything invalid in the file is a fatal error. */ 1922 1923static void 1924read_specs (const char *filename, int main_p) 1925{ 1926 char *buffer; 1927 char *p; 1928 1929 buffer = load_specs (filename); 1930 1931 /* Scan BUFFER for specs, putting them in the vector. */ 1932 p = buffer; 1933 while (1) 1934 { 1935 char *suffix; 1936 char *spec; 1937 char *in, *out, *p1, *p2, *p3; 1938 1939 /* Advance P in BUFFER to the next nonblank nocomment line. */ 1940 p = skip_whitespace (p); 1941 if (*p == 0) 1942 break; 1943 1944 /* Is this a special command that starts with '%'? */ 1945 /* Don't allow this for the main specs file, since it would 1946 encourage people to overwrite it. */ 1947 if (*p == '%' && !main_p) 1948 { 1949 p1 = p; 1950 while (*p && *p != '\n') 1951 p++; 1952 1953 /* Skip '\n'. */ 1954 p++; 1955 1956 if (!strncmp (p1, "%include", sizeof ("%include") - 1) 1957 && (p1[sizeof "%include" - 1] == ' ' 1958 || p1[sizeof "%include" - 1] == '\t')) 1959 { 1960 char *new_filename; 1961 1962 p1 += sizeof ("%include"); 1963 while (*p1 == ' ' || *p1 == '\t') 1964 p1++; 1965 1966 if (*p1++ != '<' || p[-2] != '>') 1967 fatal ("specs %%include syntax malformed after %ld characters", 1968 (long) (p1 - buffer + 1)); 1969 1970 p[-2] = '\0'; 1971 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1972 read_specs (new_filename ? new_filename : p1, FALSE); 1973 continue; 1974 } 1975 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1) 1976 && (p1[sizeof "%include_noerr" - 1] == ' ' 1977 || p1[sizeof "%include_noerr" - 1] == '\t')) 1978 { 1979 char *new_filename; 1980 1981 p1 += sizeof "%include_noerr"; 1982 while (*p1 == ' ' || *p1 == '\t') 1983 p1++; 1984 1985 if (*p1++ != '<' || p[-2] != '>') 1986 fatal ("specs %%include syntax malformed after %ld characters", 1987 (long) (p1 - buffer + 1)); 1988 1989 p[-2] = '\0'; 1990 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1991 if (new_filename) 1992 read_specs (new_filename, FALSE); 1993 else if (verbose_flag) 1994 notice ("could not find specs file %s\n", p1); 1995 continue; 1996 } 1997 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1) 1998 && (p1[sizeof "%rename" - 1] == ' ' 1999 || p1[sizeof "%rename" - 1] == '\t')) 2000 { 2001 int name_len; 2002 struct spec_list *sl; 2003 struct spec_list *newsl; 2004 2005 /* Get original name. */ 2006 p1 += sizeof "%rename"; 2007 while (*p1 == ' ' || *p1 == '\t') 2008 p1++; 2009 2010 if (! ISALPHA ((unsigned char) *p1)) 2011 fatal ("specs %%rename syntax malformed after %ld characters", 2012 (long) (p1 - buffer)); 2013 2014 p2 = p1; 2015 while (*p2 && !ISSPACE ((unsigned char) *p2)) 2016 p2++; 2017 2018 if (*p2 != ' ' && *p2 != '\t') 2019 fatal ("specs %%rename syntax malformed after %ld characters", 2020 (long) (p2 - buffer)); 2021 2022 name_len = p2 - p1; 2023 *p2++ = '\0'; 2024 while (*p2 == ' ' || *p2 == '\t') 2025 p2++; 2026 2027 if (! ISALPHA ((unsigned char) *p2)) 2028 fatal ("specs %%rename syntax malformed after %ld characters", 2029 (long) (p2 - buffer)); 2030 2031 /* Get new spec name. */ 2032 p3 = p2; 2033 while (*p3 && !ISSPACE ((unsigned char) *p3)) 2034 p3++; 2035 2036 if (p3 != p - 1) 2037 fatal ("specs %%rename syntax malformed after %ld characters", 2038 (long) (p3 - buffer)); 2039 *p3 = '\0'; 2040 2041 for (sl = specs; sl; sl = sl->next) 2042 if (name_len == sl->name_len && !strcmp (sl->name, p1)) 2043 break; 2044 2045 if (!sl) 2046 fatal ("specs %s spec was not found to be renamed", p1); 2047 2048 if (strcmp (p1, p2) == 0) 2049 continue; 2050 2051 for (newsl = specs; newsl; newsl = newsl->next) 2052 if (strcmp (newsl->name, p2) == 0) 2053 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'", 2054 filename, p1, p2); 2055 2056 if (verbose_flag) 2057 { 2058 notice ("rename spec %s to %s\n", p1, p2); 2059#ifdef DEBUG_SPECS 2060 notice ("spec is '%s'\n\n", *(sl->ptr_spec)); 2061#endif 2062 } 2063 2064 set_spec (p2, *(sl->ptr_spec)); 2065 if (sl->alloc_p) 2066 free ((void *) *(sl->ptr_spec)); 2067 2068 *(sl->ptr_spec) = ""; 2069 sl->alloc_p = 0; 2070 continue; 2071 } 2072 else 2073 fatal ("specs unknown %% command after %ld characters", 2074 (long) (p1 - buffer)); 2075 } 2076 2077 /* Find the colon that should end the suffix. */ 2078 p1 = p; 2079 while (*p1 && *p1 != ':' && *p1 != '\n') 2080 p1++; 2081 2082 /* The colon shouldn't be missing. */ 2083 if (*p1 != ':') 2084 fatal ("specs file malformed after %ld characters", 2085 (long) (p1 - buffer)); 2086 2087 /* Skip back over trailing whitespace. */ 2088 p2 = p1; 2089 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) 2090 p2--; 2091 2092 /* Copy the suffix to a string. */ 2093 suffix = save_string (p, p2 - p); 2094 /* Find the next line. */ 2095 p = skip_whitespace (p1 + 1); 2096 if (p[1] == 0) 2097 fatal ("specs file malformed after %ld characters", 2098 (long) (p - buffer)); 2099 2100 p1 = p; 2101 /* Find next blank line or end of string. */ 2102 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0'))) 2103 p1++; 2104 2105 /* Specs end at the blank line and do not include the newline. */ 2106 spec = save_string (p, p1 - p); 2107 p = p1; 2108 2109 /* Delete backslash-newline sequences from the spec. */ 2110 in = spec; 2111 out = spec; 2112 while (*in != 0) 2113 { 2114 if (in[0] == '\\' && in[1] == '\n') 2115 in += 2; 2116 else if (in[0] == '#') 2117 while (*in && *in != '\n') 2118 in++; 2119 2120 else 2121 *out++ = *in++; 2122 } 2123 *out = 0; 2124 2125 if (suffix[0] == '*') 2126 { 2127 if (! strcmp (suffix, "*link_command")) 2128 link_command_spec = spec; 2129 else 2130 set_spec (suffix + 1, spec); 2131 } 2132 else 2133 { 2134 /* Add this pair to the vector. */ 2135 compilers 2136 = xrealloc (compilers, 2137 (n_compilers + 2) * sizeof (struct compiler)); 2138 2139 compilers[n_compilers].suffix = suffix; 2140 compilers[n_compilers].spec = spec; 2141 n_compilers++; 2142 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]); 2143 } 2144 2145 if (*suffix == 0) 2146 link_command_spec = spec; 2147 } 2148 2149 if (link_command_spec == 0) 2150 fatal ("spec file has no spec for linking"); 2151} 2152 2153/* Record the names of temporary files we tell compilers to write, 2154 and delete them at the end of the run. */ 2155 2156/* This is the common prefix we use to make temp file names. 2157 It is chosen once for each run of this program. 2158 It is substituted into a spec by %g or %j. 2159 Thus, all temp file names contain this prefix. 2160 In practice, all temp file names start with this prefix. 2161 2162 This prefix comes from the envvar TMPDIR if it is defined; 2163 otherwise, from the P_tmpdir macro if that is defined; 2164 otherwise, in /usr/tmp or /tmp; 2165 or finally the current directory if all else fails. */ 2166 2167static const char *temp_filename; 2168 2169/* Length of the prefix. */ 2170 2171static int temp_filename_length; 2172 2173/* Define the list of temporary files to delete. */ 2174 2175struct temp_file 2176{ 2177 const char *name; 2178 struct temp_file *next; 2179}; 2180 2181/* Queue of files to delete on success or failure of compilation. */ 2182static struct temp_file *always_delete_queue; 2183/* Queue of files to delete on failure of compilation. */ 2184static struct temp_file *failure_delete_queue; 2185 2186/* Record FILENAME as a file to be deleted automatically. 2187 ALWAYS_DELETE nonzero means delete it if all compilation succeeds; 2188 otherwise delete it in any case. 2189 FAIL_DELETE nonzero means delete it if a compilation step fails; 2190 otherwise delete it in any case. */ 2191 2192void 2193record_temp_file (const char *filename, int always_delete, int fail_delete) 2194{ 2195 char *const name = xstrdup (filename); 2196 2197 if (always_delete) 2198 { 2199 struct temp_file *temp; 2200 for (temp = always_delete_queue; temp; temp = temp->next) 2201 if (! strcmp (name, temp->name)) 2202 goto already1; 2203 2204 temp = xmalloc (sizeof (struct temp_file)); 2205 temp->next = always_delete_queue; 2206 temp->name = name; 2207 always_delete_queue = temp; 2208 2209 already1:; 2210 } 2211 2212 if (fail_delete) 2213 { 2214 struct temp_file *temp; 2215 for (temp = failure_delete_queue; temp; temp = temp->next) 2216 if (! strcmp (name, temp->name)) 2217 goto already2; 2218 2219 temp = xmalloc (sizeof (struct temp_file)); 2220 temp->next = failure_delete_queue; 2221 temp->name = name; 2222 failure_delete_queue = temp; 2223 2224 already2:; 2225 } 2226} 2227 2228/* Delete all the temporary files whose names we previously recorded. */ 2229 2230static void 2231delete_if_ordinary (const char *name) 2232{ 2233 struct stat st; 2234#ifdef DEBUG 2235 int i, c; 2236 2237 printf ("Delete %s? (y or n) ", name); 2238 fflush (stdout); 2239 i = getchar (); 2240 if (i != '\n') 2241 while ((c = getchar ()) != '\n' && c != EOF) 2242 ; 2243 2244 if (i == 'y' || i == 'Y') 2245#endif /* DEBUG */ 2246 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode)) 2247 if (unlink (name) < 0) 2248 if (verbose_flag) 2249 perror_with_name (name); 2250} 2251 2252static void 2253delete_temp_files (void) 2254{ 2255 struct temp_file *temp; 2256 2257 for (temp = always_delete_queue; temp; temp = temp->next) 2258 delete_if_ordinary (temp->name); 2259 always_delete_queue = 0; 2260} 2261 2262/* Delete all the files to be deleted on error. */ 2263 2264static void 2265delete_failure_queue (void) 2266{ 2267 struct temp_file *temp; 2268 2269 for (temp = failure_delete_queue; temp; temp = temp->next) 2270 delete_if_ordinary (temp->name); 2271} 2272 2273static void 2274clear_failure_queue (void) 2275{ 2276 failure_delete_queue = 0; 2277} 2278 2279/* Build a list of search directories from PATHS. 2280 PREFIX is a string to prepend to the list. 2281 If CHECK_DIR_P is nonzero we ensure the directory exists. 2282 This is used mostly by putenv_from_prefixes so we use `collect_obstack'. 2283 It is also used by the --print-search-dirs flag. */ 2284 2285static char * 2286build_search_list (struct path_prefix *paths, const char *prefix, 2287 int check_dir_p) 2288{ 2289 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0; 2290 int just_suffix_len 2291 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0; 2292 int first_time = TRUE; 2293 struct prefix_list *pprefix; 2294 2295 obstack_grow (&collect_obstack, prefix, strlen (prefix)); 2296 obstack_1grow (&collect_obstack, '='); 2297 2298 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next) 2299 { 2300 int len = strlen (pprefix->prefix); 2301 2302 if (machine_suffix 2303 && (! check_dir_p 2304 || is_directory (pprefix->prefix, machine_suffix, 0))) 2305 { 2306 if (!first_time) 2307 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2308 2309 first_time = FALSE; 2310 obstack_grow (&collect_obstack, pprefix->prefix, len); 2311 obstack_grow (&collect_obstack, machine_suffix, suffix_len); 2312 } 2313 2314 if (just_machine_suffix 2315 && pprefix->require_machine_suffix == 2 2316 && (! check_dir_p 2317 || is_directory (pprefix->prefix, just_machine_suffix, 0))) 2318 { 2319 if (! first_time) 2320 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2321 2322 first_time = FALSE; 2323 obstack_grow (&collect_obstack, pprefix->prefix, len); 2324 obstack_grow (&collect_obstack, just_machine_suffix, 2325 just_suffix_len); 2326 } 2327 2328 if (! pprefix->require_machine_suffix) 2329 { 2330 if (! first_time) 2331 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2332 2333 first_time = FALSE; 2334 obstack_grow (&collect_obstack, pprefix->prefix, len); 2335 } 2336 } 2337 2338 obstack_1grow (&collect_obstack, '\0'); 2339 return obstack_finish (&collect_obstack); 2340} 2341 2342/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 2343 for collect. */ 2344 2345static void 2346putenv_from_prefixes (struct path_prefix *paths, const char *env_var) 2347{ 2348 putenv (build_search_list (paths, env_var, 1)); 2349} 2350 2351/* Check whether NAME can be accessed in MODE. This is like access, 2352 except that it never considers directories to be executable. */ 2353 2354static int 2355access_check (const char *name, int mode) 2356{ 2357 if (mode == X_OK) 2358 { 2359 struct stat st; 2360 2361 if (stat (name, &st) < 0 2362 || S_ISDIR (st.st_mode)) 2363 return -1; 2364 } 2365 2366 return access (name, mode); 2367} 2368 2369/* Search for NAME using the prefix list PREFIXES. MODE is passed to 2370 access to check permissions. 2371 Return 0 if not found, otherwise return its name, allocated with malloc. */ 2372 2373static char * 2374find_a_file (struct path_prefix *pprefix, const char *name, int mode, 2375 int multilib) 2376{ 2377 char *temp; 2378 const char *const file_suffix = 2379 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : ""); 2380 struct prefix_list *pl; 2381 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1; 2382 const char *multilib_name, *multilib_os_name; 2383 2384#ifdef DEFAULT_ASSEMBLER 2385 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) 2386 return xstrdup (DEFAULT_ASSEMBLER); 2387#endif 2388 2389#ifdef DEFAULT_LINKER 2390 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) 2391 return xstrdup (DEFAULT_LINKER); 2392#endif 2393 2394 if (machine_suffix) 2395 len += strlen (machine_suffix); 2396 2397 multilib_name = name; 2398 multilib_os_name = name; 2399 if (multilib && multilib_os_dir) 2400 { 2401 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0; 2402 int len2 = strlen (multilib_os_dir) + 1; 2403 2404 len += len1 > len2 ? len1 : len2; 2405 if (multilib_dir) 2406 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name, 2407 NULL)); 2408 if (strcmp (multilib_os_dir, ".") != 0) 2409 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name, 2410 NULL)); 2411 } 2412 2413 temp = xmalloc (len); 2414 2415 /* Determine the filename to execute (special case for absolute paths). */ 2416 2417 if (IS_ABSOLUTE_PATH (name)) 2418 { 2419 if (access (name, mode) == 0) 2420 { 2421 strcpy (temp, name); 2422 return temp; 2423 } 2424 } 2425 else 2426 for (pl = pprefix->plist; pl; pl = pl->next) 2427 { 2428 const char *this_name 2429 = pl->os_multilib ? multilib_os_name : multilib_name; 2430 2431 if (machine_suffix) 2432 { 2433 /* Some systems have a suffix for executable files. 2434 So try appending that first. */ 2435 if (file_suffix[0] != 0) 2436 { 2437 strcpy (temp, pl->prefix); 2438 strcat (temp, machine_suffix); 2439 strcat (temp, multilib_name); 2440 strcat (temp, file_suffix); 2441 if (access_check (temp, mode) == 0) 2442 { 2443 if (pl->used_flag_ptr != 0) 2444 *pl->used_flag_ptr = 1; 2445 return temp; 2446 } 2447 } 2448 2449 /* Now try just the multilib_name. */ 2450 strcpy (temp, pl->prefix); 2451 strcat (temp, machine_suffix); 2452 strcat (temp, multilib_name); 2453 if (access_check (temp, mode) == 0) 2454 { 2455 if (pl->used_flag_ptr != 0) 2456 *pl->used_flag_ptr = 1; 2457 return temp; 2458 } 2459 } 2460 2461 /* Certain prefixes are tried with just the machine type, 2462 not the version. This is used for finding as, ld, etc. */ 2463 if (just_machine_suffix && pl->require_machine_suffix == 2) 2464 { 2465 /* Some systems have a suffix for executable files. 2466 So try appending that first. */ 2467 if (file_suffix[0] != 0) 2468 { 2469 strcpy (temp, pl->prefix); 2470 strcat (temp, just_machine_suffix); 2471 strcat (temp, multilib_name); 2472 strcat (temp, file_suffix); 2473 if (access_check (temp, mode) == 0) 2474 { 2475 if (pl->used_flag_ptr != 0) 2476 *pl->used_flag_ptr = 1; 2477 return temp; 2478 } 2479 } 2480 2481 strcpy (temp, pl->prefix); 2482 strcat (temp, just_machine_suffix); 2483 strcat (temp, multilib_name); 2484 if (access_check (temp, mode) == 0) 2485 { 2486 if (pl->used_flag_ptr != 0) 2487 *pl->used_flag_ptr = 1; 2488 return temp; 2489 } 2490 } 2491 2492 /* Certain prefixes can't be used without the machine suffix 2493 when the machine or version is explicitly specified. */ 2494 if (! pl->require_machine_suffix) 2495 { 2496 /* Some systems have a suffix for executable files. 2497 So try appending that first. */ 2498 if (file_suffix[0] != 0) 2499 { 2500 strcpy (temp, pl->prefix); 2501 strcat (temp, this_name); 2502 strcat (temp, file_suffix); 2503 if (access_check (temp, mode) == 0) 2504 { 2505 if (pl->used_flag_ptr != 0) 2506 *pl->used_flag_ptr = 1; 2507 return temp; 2508 } 2509 } 2510 2511 strcpy (temp, pl->prefix); 2512 strcat (temp, this_name); 2513 if (access_check (temp, mode) == 0) 2514 { 2515 if (pl->used_flag_ptr != 0) 2516 *pl->used_flag_ptr = 1; 2517 return temp; 2518 } 2519 } 2520 } 2521 2522 free (temp); 2523 return 0; 2524} 2525 2526/* Ranking of prefixes in the sort list. -B prefixes are put before 2527 all others. */ 2528 2529enum path_prefix_priority 2530{ 2531 PREFIX_PRIORITY_B_OPT, 2532 PREFIX_PRIORITY_LAST 2533}; 2534 2535/* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending 2536 order according to PRIORITY. Within each PRIORITY, new entries are 2537 appended. 2538 2539 If WARN is nonzero, we will warn if no file is found 2540 through this prefix. WARN should point to an int 2541 which will be set to 1 if this entry is used. 2542 2543 COMPONENT is the value to be passed to update_path. 2544 2545 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without 2546 the complete value of machine_suffix. 2547 2 means try both machine_suffix and just_machine_suffix. */ 2548 2549static void 2550add_prefix (struct path_prefix *pprefix, const char *prefix, 2551 const char *component, /* enum prefix_priority */ int priority, 2552 int require_machine_suffix, int *warn, int os_multilib) 2553{ 2554 struct prefix_list *pl, **prev; 2555 int len; 2556 2557 for (prev = &pprefix->plist; 2558 (*prev) != NULL && (*prev)->priority <= priority; 2559 prev = &(*prev)->next) 2560 ; 2561 2562 /* Keep track of the longest prefix. */ 2563 2564 prefix = update_path (prefix, component); 2565 len = strlen (prefix); 2566 if (len > pprefix->max_len) 2567 pprefix->max_len = len; 2568 2569 pl = xmalloc (sizeof (struct prefix_list)); 2570 pl->prefix = prefix; 2571 pl->require_machine_suffix = require_machine_suffix; 2572 pl->used_flag_ptr = warn; 2573 pl->priority = priority; 2574 pl->os_multilib = os_multilib; 2575 if (warn) 2576 *warn = 0; 2577 2578 /* Insert after PREV. */ 2579 pl->next = (*prev); 2580 (*prev) = pl; 2581} 2582 2583/* Same as add_prefix, but prepending target_system_root to prefix. */ 2584static void 2585add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix, 2586 const char *component, 2587 /* enum prefix_priority */ int priority, 2588 int require_machine_suffix, int *warn, int os_multilib) 2589{ 2590 if (!IS_ABSOLUTE_PATH (prefix)) 2591 abort (); 2592 2593 if (target_system_root) 2594 { 2595 if (target_sysroot_suffix) 2596 prefix = concat (target_sysroot_suffix, prefix, NULL); 2597 prefix = concat (target_system_root, prefix, NULL); 2598 2599 /* We have to override this because GCC's notion of sysroot 2600 moves along with GCC. */ 2601 component = "GCC"; 2602 } 2603 2604 add_prefix (pprefix, prefix, component, priority, 2605 require_machine_suffix, warn, os_multilib); 2606} 2607 2608/* Execute the command specified by the arguments on the current line of spec. 2609 When using pipes, this includes several piped-together commands 2610 with `|' between them. 2611 2612 Return 0 if successful, -1 if failed. */ 2613 2614static int 2615execute (void) 2616{ 2617 int i; 2618 int n_commands; /* # of command. */ 2619 char *string; 2620 struct command 2621 { 2622 const char *prog; /* program name. */ 2623 const char **argv; /* vector of args. */ 2624 int pid; /* pid of process for this command. */ 2625 }; 2626 2627 struct command *commands; /* each command buffer with above info. */ 2628 2629 if (processing_spec_function) 2630 abort (); 2631 2632 /* Count # of piped commands. */ 2633 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2634 if (strcmp (argbuf[i], "|") == 0) 2635 n_commands++; 2636 2637 /* Get storage for each command. */ 2638 commands = alloca (n_commands * sizeof (struct command)); 2639 2640 /* Split argbuf into its separate piped processes, 2641 and record info about each one. 2642 Also search for the programs that are to be run. */ 2643 2644 commands[0].prog = argbuf[0]; /* first command. */ 2645 commands[0].argv = &argbuf[0]; 2646 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0); 2647 2648 if (string) 2649 commands[0].argv[0] = string; 2650 2651 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2652 if (strcmp (argbuf[i], "|") == 0) 2653 { /* each command. */ 2654#if defined (__MSDOS__) || defined (OS2) || defined (VMS) 2655 fatal ("-pipe not supported"); 2656#endif 2657 argbuf[i] = 0; /* termination of command args. */ 2658 commands[n_commands].prog = argbuf[i + 1]; 2659 commands[n_commands].argv = &argbuf[i + 1]; 2660 string = find_a_file (&exec_prefixes, commands[n_commands].prog, 2661 X_OK, 0); 2662 if (string) 2663 commands[n_commands].argv[0] = string; 2664 n_commands++; 2665 } 2666 2667 argbuf[argbuf_index] = 0; 2668 2669 /* If -v, print what we are about to do, and maybe query. */ 2670 2671 if (verbose_flag) 2672 { 2673 /* For help listings, put a blank line between sub-processes. */ 2674 if (print_help_list) 2675 fputc ('\n', stderr); 2676 2677 /* Print each piped command as a separate line. */ 2678 for (i = 0; i < n_commands; i++) 2679 { 2680 const char *const *j; 2681 2682 if (verbose_only_flag) 2683 { 2684 for (j = commands[i].argv; *j; j++) 2685 { 2686 const char *p; 2687 fprintf (stderr, " \""); 2688 for (p = *j; *p; ++p) 2689 { 2690 if (*p == '"' || *p == '\\' || *p == '$') 2691 fputc ('\\', stderr); 2692 fputc (*p, stderr); 2693 } 2694 fputc ('"', stderr); 2695 } 2696 } 2697 else 2698 for (j = commands[i].argv; *j; j++) 2699 fprintf (stderr, " %s", *j); 2700 2701 /* Print a pipe symbol after all but the last command. */ 2702 if (i + 1 != n_commands) 2703 fprintf (stderr, " |"); 2704 fprintf (stderr, "\n"); 2705 } 2706 fflush (stderr); 2707 if (verbose_only_flag != 0) 2708 { 2709 /* verbose_only_flag should act as if the spec was 2710 executed, so increment execution_count before 2711 returning. This prevents spurious warnings about 2712 unused linker input files, etc. */ 2713 execution_count++; 2714 return 0; 2715 } 2716#ifdef DEBUG 2717 notice ("\nGo ahead? (y or n) "); 2718 fflush (stderr); 2719 i = getchar (); 2720 if (i != '\n') 2721 while (getchar () != '\n') 2722 ; 2723 2724 if (i != 'y' && i != 'Y') 2725 return 0; 2726#endif /* DEBUG */ 2727 } 2728 2729#ifdef ENABLE_VALGRIND_CHECKING 2730 /* Run the each command through valgrind. To simplify prepending the 2731 path to valgrind and the option "-q" (for quiet operation unless 2732 something triggers), we allocate a separate argv array. */ 2733 2734 for (i = 0; i < n_commands; i++) 2735 { 2736 const char **argv; 2737 int argc; 2738 int j; 2739 2740 for (argc = 0; commands[i].argv[argc] != NULL; argc++) 2741 ; 2742 2743 argv = alloca ((argc + 3) * sizeof (char *)); 2744 2745 argv[0] = VALGRIND_PATH; 2746 argv[1] = "-q"; 2747 for (j = 2; j < argc + 2; j++) 2748 argv[j] = commands[i].argv[j - 2]; 2749 argv[j] = NULL; 2750 2751 commands[i].argv = argv; 2752 commands[i].prog = argv[0]; 2753 } 2754#endif 2755 2756 /* Run each piped subprocess. */ 2757 2758 for (i = 0; i < n_commands; i++) 2759 { 2760 char *errmsg_fmt, *errmsg_arg; 2761 const char *string = commands[i].argv[0]; 2762 2763 /* For some bizarre reason, the second argument of execvp() is 2764 char *const *, not const char *const *. */ 2765 commands[i].pid = pexecute (string, (char *const *) commands[i].argv, 2766 programname, temp_filename, 2767 &errmsg_fmt, &errmsg_arg, 2768 ((i == 0 ? PEXECUTE_FIRST : 0) 2769 | (i + 1 == n_commands ? PEXECUTE_LAST : 0) 2770 | (string == commands[i].prog 2771 ? PEXECUTE_SEARCH : 0) 2772 | (verbose_flag ? PEXECUTE_VERBOSE : 0))); 2773 2774 if (commands[i].pid == -1) 2775 pfatal_pexecute (errmsg_fmt, errmsg_arg); 2776 2777 if (string != commands[i].prog) 2778 free ((void *) string); 2779 } 2780 2781 execution_count++; 2782 2783 /* Wait for all the subprocesses to finish. 2784 We don't care what order they finish in; 2785 we know that N_COMMANDS waits will get them all. 2786 Ignore subprocesses that we don't know about, 2787 since they can be spawned by the process that exec'ed us. */ 2788 2789 { 2790 int ret_code = 0; 2791#ifdef HAVE_GETRUSAGE 2792 struct timeval d; 2793 double ut = 0.0, st = 0.0; 2794#endif 2795 2796 for (i = 0; i < n_commands;) 2797 { 2798 int j; 2799 int status; 2800 int pid; 2801 2802 pid = pwait (commands[i].pid, &status, 0); 2803 if (pid < 0) 2804 abort (); 2805 2806#ifdef HAVE_GETRUSAGE 2807 if (report_times) 2808 { 2809 /* getrusage returns the total resource usage of all children 2810 up to now. Copy the previous values into prus, get the 2811 current statistics, then take the difference. */ 2812 2813 prus = rus; 2814 getrusage (RUSAGE_CHILDREN, &rus); 2815 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec; 2816 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec; 2817 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2818 2819 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec; 2820 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec; 2821 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2822 } 2823#endif 2824 2825 for (j = 0; j < n_commands; j++) 2826 if (commands[j].pid == pid) 2827 { 2828 i++; 2829 if (WIFSIGNALED (status)) 2830 { 2831#ifdef SIGPIPE 2832 /* SIGPIPE is a special case. It happens in -pipe mode 2833 when the compiler dies before the preprocessor is 2834 done, or the assembler dies before the compiler is 2835 done. There's generally been an error already, and 2836 this is just fallout. So don't generate another error 2837 unless we would otherwise have succeeded. */ 2838 if (WTERMSIG (status) == SIGPIPE 2839 && (signal_count || greatest_status >= MIN_FATAL_STATUS)) 2840 ; 2841 else 2842#endif 2843 fatal ("\ 2844Internal error: %s (program %s)\n\ 2845Please submit a full bug report.\n\ 2846See %s for instructions.", 2847 strsignal (WTERMSIG (status)), commands[j].prog, 2848 bug_report_url); 2849 signal_count++; 2850 ret_code = -1; 2851 } 2852 else if (WIFEXITED (status) 2853 && WEXITSTATUS (status) >= MIN_FATAL_STATUS) 2854 { 2855 if (WEXITSTATUS (status) > greatest_status) 2856 greatest_status = WEXITSTATUS (status); 2857 ret_code = -1; 2858 } 2859#ifdef HAVE_GETRUSAGE 2860 if (report_times && ut + st != 0) 2861 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st); 2862#endif 2863 break; 2864 } 2865 } 2866 return ret_code; 2867 } 2868} 2869 2870/* Find all the switches given to us 2871 and make a vector describing them. 2872 The elements of the vector are strings, one per switch given. 2873 If a switch uses following arguments, then the `part1' field 2874 is the switch itself and the `args' field 2875 is a null-terminated vector containing the following arguments. 2876 The `live_cond' field is: 2877 0 when initialized 2878 1 if the switch is true in a conditional spec, 2879 -1 if false (overridden by a later switch) 2880 -2 if this switch should be ignored (used in %<S) 2881 The `validated' field is nonzero if any spec has looked at this switch; 2882 if it remains zero at the end of the run, it must be meaningless. */ 2883 2884#define SWITCH_OK 0 2885#define SWITCH_FALSE -1 2886#define SWITCH_IGNORE -2 2887#define SWITCH_LIVE 1 2888 2889struct switchstr 2890{ 2891 const char *part1; 2892 const char **args; 2893 int live_cond; 2894 unsigned char validated; 2895 unsigned char ordering; 2896}; 2897 2898static struct switchstr *switches; 2899 2900static int n_switches; 2901 2902struct infile 2903{ 2904 const char *name; 2905 const char *language; 2906}; 2907 2908/* Also a vector of input files specified. */ 2909 2910static struct infile *infiles; 2911 2912int n_infiles; 2913 2914/* True if multiple input files are being compiled to a single 2915 assembly file. */ 2916 2917static bool combine_inputs; 2918 2919/* This counts the number of libraries added by lang_specific_driver, so that 2920 we can tell if there were any user supplied any files or libraries. */ 2921 2922static int added_libraries; 2923 2924/* And a vector of corresponding output files is made up later. */ 2925 2926const char **outfiles; 2927 2928/* Used to track if none of the -B paths are used. */ 2929static int warn_B; 2930 2931/* Gives value to pass as "warn" to add_prefix for standard prefixes. */ 2932static int *warn_std_ptr = 0; 2933 2934#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2935 2936/* Convert NAME to a new name if it is the standard suffix. DO_EXE 2937 is true if we should look for an executable suffix. DO_OBJ 2938 is true if we should look for an object suffix. */ 2939 2940static const char * 2941convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED, 2942 int do_obj ATTRIBUTE_UNUSED) 2943{ 2944#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2945 int i; 2946#endif 2947 int len; 2948 2949 if (name == NULL) 2950 return NULL; 2951 2952 len = strlen (name); 2953 2954#ifdef HAVE_TARGET_OBJECT_SUFFIX 2955 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */ 2956 if (do_obj && len > 2 2957 && name[len - 2] == '.' 2958 && name[len - 1] == 'o') 2959 { 2960 obstack_grow (&obstack, name, len - 2); 2961 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 2962 name = obstack_finish (&obstack); 2963 } 2964#endif 2965 2966#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2967 /* If there is no filetype, make it the executable suffix (which includes 2968 the "."). But don't get confused if we have just "-o". */ 2969 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-')) 2970 return name; 2971 2972 for (i = len - 1; i >= 0; i--) 2973 if (IS_DIR_SEPARATOR (name[i])) 2974 break; 2975 2976 for (i++; i < len; i++) 2977 if (name[i] == '.') 2978 return name; 2979 2980 obstack_grow (&obstack, name, len); 2981 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX, 2982 strlen (TARGET_EXECUTABLE_SUFFIX)); 2983 name = obstack_finish (&obstack); 2984#endif 2985 2986 return name; 2987} 2988#endif 2989 2990/* Display the command line switches accepted by gcc. */ 2991static void 2992display_help (void) 2993{ 2994 printf (_("Usage: %s [options] file...\n"), programname); 2995 fputs (_("Options:\n"), stdout); 2996 2997 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout); 2998 fputs (_(" --help Display this information\n"), stdout); 2999 fputs (_(" --target-help Display target specific command line options\n"), stdout); 3000 if (! verbose_flag) 3001 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout); 3002 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout); 3003 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout); 3004 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout); 3005 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout); 3006 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout); 3007 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout); 3008 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout); 3009 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout); 3010 fputs (_("\ 3011 -print-multi-lib Display the mapping between command line options and\n\ 3012 multiple library search directories\n"), stdout); 3013 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout); 3014 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout); 3015 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout); 3016 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout); 3017 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout); 3018 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout); 3019 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout); 3020 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout); 3021 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout); 3022 fputs (_(" -time Time the execution of each subprocess\n"), stdout); 3023 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout); 3024 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout); 3025 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout); 3026 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout); 3027 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout); 3028 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout); 3029 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout); 3030 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout); 3031 fputs (_(" -S Compile only; do not assemble or link\n"), stdout); 3032 fputs (_(" -c Compile and assemble, but do not link\n"), stdout); 3033 fputs (_(" -o <file> Place the output into <file>\n"), stdout); 3034 fputs (_("\ 3035 -x <language> Specify the language of the following input files\n\ 3036 Permissible languages include: c c++ assembler none\n\ 3037 'none' means revert to the default behavior of\n\ 3038 guessing the language based on the file's extension\n\ 3039"), stdout); 3040 3041 printf (_("\ 3042\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\ 3043 passed on to the various sub-processes invoked by %s. In order to pass\n\ 3044 other options on to these processes the -W<letter> options must be used.\n\ 3045"), programname); 3046 3047 /* The rest of the options are displayed by invocations of the various 3048 sub-processes. */ 3049} 3050 3051static void 3052add_preprocessor_option (const char *option, int len) 3053{ 3054 n_preprocessor_options++; 3055 3056 if (! preprocessor_options) 3057 preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *)); 3058 else 3059 preprocessor_options = xrealloc (preprocessor_options, 3060 n_preprocessor_options * sizeof (char *)); 3061 3062 preprocessor_options [n_preprocessor_options - 1] = 3063 save_string (option, len); 3064} 3065 3066static void 3067add_assembler_option (const char *option, int len) 3068{ 3069 n_assembler_options++; 3070 3071 if (! assembler_options) 3072 assembler_options = xmalloc (n_assembler_options * sizeof (char *)); 3073 else 3074 assembler_options = xrealloc (assembler_options, 3075 n_assembler_options * sizeof (char *)); 3076 3077 assembler_options [n_assembler_options - 1] = save_string (option, len); 3078} 3079 3080static void 3081add_linker_option (const char *option, int len) 3082{ 3083 n_linker_options++; 3084 3085 if (! linker_options) 3086 linker_options = xmalloc (n_linker_options * sizeof (char *)); 3087 else 3088 linker_options = xrealloc (linker_options, 3089 n_linker_options * sizeof (char *)); 3090 3091 linker_options [n_linker_options - 1] = save_string (option, len); 3092} 3093 3094/* Create the vector `switches' and its contents. 3095 Store its length in `n_switches'. */ 3096 3097static void 3098process_command (int argc, const char **argv) 3099{ 3100 int i; 3101 const char *temp; 3102 char *temp1; 3103 const char *spec_lang = 0; 3104 int last_language_n_infiles; 3105 int have_c = 0; 3106 int have_o = 0; 3107 int lang_n_infiles = 0; 3108#ifdef MODIFY_TARGET_NAME 3109 int is_modify_target_name; 3110 int j; 3111#endif 3112 3113 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX"); 3114 3115 n_switches = 0; 3116 n_infiles = 0; 3117 added_libraries = 0; 3118 3119 /* Figure compiler version from version string. */ 3120 3121 compiler_version = temp1 = xstrdup (version_string); 3122 3123 for (; *temp1; ++temp1) 3124 { 3125 if (*temp1 == ' ') 3126 { 3127 *temp1 = '\0'; 3128 break; 3129 } 3130 } 3131 3132 /* If there is a -V or -b option (or both), process it now, before 3133 trying to interpret the rest of the command line. */ 3134 if (argc > 1 && argv[1][0] == '-' 3135 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3136 { 3137 const char *new_version = DEFAULT_TARGET_VERSION; 3138 const char *new_machine = DEFAULT_TARGET_MACHINE; 3139 const char *progname = argv[0]; 3140 char **new_argv; 3141 char *new_argv0; 3142 int baselen; 3143 3144 while (argc > 1 && argv[1][0] == '-' 3145 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3146 { 3147 char opt = argv[1][1]; 3148 const char *arg; 3149 if (argv[1][2] != '\0') 3150 { 3151 arg = argv[1] + 2; 3152 argc -= 1; 3153 argv += 1; 3154 } 3155 else if (argc > 2) 3156 { 3157 arg = argv[2]; 3158 argc -= 2; 3159 argv += 2; 3160 } 3161 else 3162 fatal ("`-%c' option must have argument", opt); 3163 if (opt == 'V') 3164 new_version = arg; 3165 else 3166 new_machine = arg; 3167 } 3168 3169 for (baselen = strlen (progname); baselen > 0; baselen--) 3170 if (IS_DIR_SEPARATOR (progname[baselen-1])) 3171 break; 3172 new_argv0 = xmemdup (progname, baselen, 3173 baselen + concat_length (new_version, new_machine, 3174 "-gcc-", NULL) + 1); 3175 strcpy (new_argv0 + baselen, new_machine); 3176 strcat (new_argv0, "-gcc-"); 3177 strcat (new_argv0, new_version); 3178 3179 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]), 3180 (argc + 1) * sizeof (argv[0])); 3181 new_argv[0] = new_argv0; 3182 3183 execvp (new_argv0, new_argv); 3184 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno)); 3185 } 3186 3187 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX, 3188 see if we can create it from the pathname specified in argv[0]. */ 3189 3190 gcc_libexec_prefix = standard_libexec_prefix; 3191#ifndef FREEBSD_NATIVE 3192#ifndef VMS 3193 /* FIXME: make_relative_prefix doesn't yet work for VMS. */ 3194 if (!gcc_exec_prefix) 3195 { 3196 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix, 3197 standard_exec_prefix); 3198 gcc_libexec_prefix = make_relative_prefix (argv[0], 3199 standard_bindir_prefix, 3200 standard_libexec_prefix); 3201 if (gcc_exec_prefix) 3202 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL)); 3203 } 3204 else 3205 gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix, 3206 standard_exec_prefix, 3207 standard_libexec_prefix); 3208#else 3209#endif 3210#endif /* not FREEBSD_NATIVE */ 3211 3212 if (gcc_exec_prefix) 3213 { 3214 int len = strlen (gcc_exec_prefix); 3215 3216 if (len > (int) sizeof ("/lib/gcc/") - 1 3217 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1]))) 3218 { 3219 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1; 3220 if (IS_DIR_SEPARATOR (*temp) 3221 && strncmp (temp + 1, "lib", 3) == 0 3222 && IS_DIR_SEPARATOR (temp[4]) 3223 && strncmp (temp + 5, "gcc", 3) == 0) 3224 len -= sizeof ("/lib/gcc/") - 1; 3225 } 3226 3227 set_std_prefix (gcc_exec_prefix, len); 3228 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC", 3229 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3230 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 3231 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3232 } 3233 3234 /* COMPILER_PATH and LIBRARY_PATH have values 3235 that are lists of directory names with colons. */ 3236 3237 GET_ENVIRONMENT (temp, "COMPILER_PATH"); 3238 if (temp) 3239 { 3240 const char *startp, *endp; 3241 char *nstore = alloca (strlen (temp) + 3); 3242 3243 startp = endp = temp; 3244 while (1) 3245 { 3246 if (*endp == PATH_SEPARATOR || *endp == 0) 3247 { 3248 strncpy (nstore, startp, endp - startp); 3249 if (endp == startp) 3250 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3251 else if (!IS_DIR_SEPARATOR (endp[-1])) 3252 { 3253 nstore[endp - startp] = DIR_SEPARATOR; 3254 nstore[endp - startp + 1] = 0; 3255 } 3256 else 3257 nstore[endp - startp] = 0; 3258 add_prefix (&exec_prefixes, nstore, 0, 3259 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3260 add_prefix (&include_prefixes, 3261 concat (nstore, "include", NULL), 3262 0, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3263 if (*endp == 0) 3264 break; 3265 endp = startp = endp + 1; 3266 } 3267 else 3268 endp++; 3269 } 3270 } 3271 3272 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV); 3273 if (temp && *cross_compile == '0') 3274 { 3275 const char *startp, *endp; 3276 char *nstore = alloca (strlen (temp) + 3); 3277 3278 startp = endp = temp; 3279 while (1) 3280 { 3281 if (*endp == PATH_SEPARATOR || *endp == 0) 3282 { 3283 strncpy (nstore, startp, endp - startp); 3284 if (endp == startp) 3285 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3286 else if (!IS_DIR_SEPARATOR (endp[-1])) 3287 { 3288 nstore[endp - startp] = DIR_SEPARATOR; 3289 nstore[endp - startp + 1] = 0; 3290 } 3291 else 3292 nstore[endp - startp] = 0; 3293 add_prefix (&startfile_prefixes, nstore, NULL, 3294 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3295 if (*endp == 0) 3296 break; 3297 endp = startp = endp + 1; 3298 } 3299 else 3300 endp++; 3301 } 3302 } 3303 3304 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */ 3305 GET_ENVIRONMENT (temp, "LPATH"); 3306 if (temp && *cross_compile == '0') 3307 { 3308 const char *startp, *endp; 3309 char *nstore = alloca (strlen (temp) + 3); 3310 3311 startp = endp = temp; 3312 while (1) 3313 { 3314 if (*endp == PATH_SEPARATOR || *endp == 0) 3315 { 3316 strncpy (nstore, startp, endp - startp); 3317 if (endp == startp) 3318 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3319 else if (!IS_DIR_SEPARATOR (endp[-1])) 3320 { 3321 nstore[endp - startp] = DIR_SEPARATOR; 3322 nstore[endp - startp + 1] = 0; 3323 } 3324 else 3325 nstore[endp - startp] = 0; 3326 add_prefix (&startfile_prefixes, nstore, NULL, 3327 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3328 if (*endp == 0) 3329 break; 3330 endp = startp = endp + 1; 3331 } 3332 else 3333 endp++; 3334 } 3335 } 3336 3337 /* Options specified as if they appeared on the command line. */ 3338 temp = getenv ("GCC_OPTIONS"); 3339 if ((temp) && (strlen (temp) > 0)) 3340 { 3341 int len; 3342 int optc = 1; 3343 int new_argc; 3344 const char **new_argv; 3345 char *envopts; 3346 3347 while (isspace (*temp)) 3348 temp++; 3349 len = strlen (temp); 3350 envopts = (char *) xmalloc (len + 1); 3351 strcpy (envopts, temp); 3352 3353 for (i = 0; i < (len - 1); i++) 3354 if ((isspace (envopts[i])) && ! (isspace (envopts[i+1]))) 3355 optc++; 3356 3357 new_argv = (const char **) alloca ((optc + argc) * sizeof(char *)); 3358 3359 for (i = 0, new_argc = 1; new_argc <= optc; new_argc++) 3360 { 3361 while (isspace (envopts[i])) 3362 i++; 3363 new_argv[new_argc] = envopts + i; 3364 while (!isspace (envopts[i]) && (envopts[i] != '\0')) 3365 i++; 3366 envopts[i++] = '\0'; 3367 } 3368 for (i = 1; i < argc; i++) 3369 new_argv[new_argc++] = argv[i]; 3370 3371 argv = new_argv; 3372 argc = new_argc; 3373 } 3374 3375 /* Convert new-style -- options to old-style. */ 3376 translate_options (&argc, (const char *const **) &argv); 3377 3378 /* Do language-specific adjustment/addition of flags. */ 3379 lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries); 3380 3381 /* Scan argv twice. Here, the first time, just count how many switches 3382 there will be in their vector, and how many input files in theirs. 3383 Here we also parse the switches that cc itself uses (e.g. -v). */ 3384 3385 for (i = 1; i < argc; i++) 3386 { 3387 if (! strcmp (argv[i], "-dumpspecs")) 3388 { 3389 struct spec_list *sl; 3390 init_spec (); 3391 for (sl = specs; sl; sl = sl->next) 3392 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec)); 3393 if (link_command_spec) 3394 printf ("*link_command:\n%s\n\n", link_command_spec); 3395 exit (0); 3396 } 3397 else if (! strcmp (argv[i], "-dumpversion")) 3398 { 3399 printf ("%s\n", spec_version); 3400 exit (0); 3401 } 3402 else if (! strcmp (argv[i], "-dumpmachine")) 3403 { 3404 printf ("%s\n", spec_machine); 3405 exit (0); 3406 } 3407 else if (strcmp (argv[i], "-fversion") == 0) 3408 { 3409 /* translate_options () has turned --version into -fversion. */ 3410 printf (_("%s (GCC) %s\n"), programname, version_string);
|
3410 _("(C)")); 3411 fputs (_("This is free software; see the source for copying conditions. There is NO\n\ 3412warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"), 3413 stdout); 3414 exit (0); 3415 } 3416 else if (strcmp (argv[i], "-fhelp") == 0) 3417 { 3418 /* translate_options () has turned --help into -fhelp. */ 3419 print_help_list = 1; 3420 3421 /* We will be passing a dummy file on to the sub-processes. */ 3422 n_infiles++; 3423 n_switches++; 3424 3425 /* CPP driver cannot obtain switch from cc1_options. */ 3426 if (is_cpp_driver) 3427 add_preprocessor_option ("--help", 6); 3428 add_assembler_option ("--help", 6); 3429 add_linker_option ("--help", 6); 3430 } 3431 else if (strcmp (argv[i], "-ftarget-help") == 0) 3432 { 3433 /* translate_options() has turned --target-help into -ftarget-help. */ 3434 target_help_flag = 1; 3435 3436 /* We will be passing a dummy file on to the sub-processes. */ 3437 n_infiles++; 3438 n_switches++; 3439 3440 /* CPP driver cannot obtain switch from cc1_options. */ 3441 if (is_cpp_driver) 3442 add_preprocessor_option ("--target-help", 13); 3443 add_assembler_option ("--target-help", 13); 3444 add_linker_option ("--target-help", 13); 3445 } 3446 else if (! strcmp (argv[i], "-pass-exit-codes")) 3447 { 3448 pass_exit_codes = 1; 3449 n_switches++; 3450 } 3451 else if (! strcmp (argv[i], "-print-search-dirs")) 3452 print_search_dirs = 1; 3453 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3454 print_file_name = "libgcc.a"; 3455 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3456 print_file_name = argv[i] + 17; 3457 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3458 print_prog_name = argv[i] + 17; 3459 else if (! strcmp (argv[i], "-print-multi-lib")) 3460 print_multi_lib = 1; 3461 else if (! strcmp (argv[i], "-print-multi-directory")) 3462 print_multi_directory = 1; 3463 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3464 print_multi_os_directory = 1; 3465 else if (! strncmp (argv[i], "-Wa,", 4)) 3466 { 3467 int prev, j; 3468 /* Pass the rest of this option to the assembler. */ 3469 3470 /* Split the argument at commas. */ 3471 prev = 4; 3472 for (j = 4; argv[i][j]; j++) 3473 if (argv[i][j] == ',') 3474 { 3475 add_assembler_option (argv[i] + prev, j - prev); 3476 prev = j + 1; 3477 } 3478 3479 /* Record the part after the last comma. */ 3480 add_assembler_option (argv[i] + prev, j - prev); 3481 } 3482 else if (! strncmp (argv[i], "-Wp,", 4)) 3483 { 3484 int prev, j; 3485 /* Pass the rest of this option to the preprocessor. */ 3486 3487 /* Split the argument at commas. */ 3488 prev = 4; 3489 for (j = 4; argv[i][j]; j++) 3490 if (argv[i][j] == ',') 3491 { 3492 add_preprocessor_option (argv[i] + prev, j - prev); 3493 prev = j + 1; 3494 } 3495 3496 /* Record the part after the last comma. */ 3497 add_preprocessor_option (argv[i] + prev, j - prev); 3498 } 3499 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3500 /* The +e options to the C++ front-end. */ 3501 n_switches++; 3502 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3503 { 3504 int j; 3505 /* Split the argument at commas. */ 3506 for (j = 3; argv[i][j]; j++) 3507 n_infiles += (argv[i][j] == ','); 3508 } 3509 else if (strcmp (argv[i], "-Xlinker") == 0) 3510 { 3511 if (i + 1 == argc) 3512 fatal ("argument to `-Xlinker' is missing"); 3513 3514 n_infiles++; 3515 i++; 3516 } 3517 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3518 { 3519 if (i + 1 == argc) 3520 fatal ("argument to `-Xpreprocessor' is missing"); 3521 3522 add_preprocessor_option (argv[i+1], strlen (argv[i+1])); 3523 } 3524 else if (strcmp (argv[i], "-Xassembler") == 0) 3525 { 3526 if (i + 1 == argc) 3527 fatal ("argument to `-Xassembler' is missing"); 3528 3529 add_assembler_option (argv[i+1], strlen (argv[i+1])); 3530 } 3531 else if (strcmp (argv[i], "-l") == 0) 3532 { 3533 if (i + 1 == argc) 3534 fatal ("argument to `-l' is missing"); 3535 3536 n_infiles++; 3537 i++; 3538 } 3539 else if (strncmp (argv[i], "-l", 2) == 0) 3540 n_infiles++; 3541 else if (strcmp (argv[i], "-save-temps") == 0) 3542 { 3543 save_temps_flag = 1; 3544 n_switches++; 3545 } 3546 else if (strcmp (argv[i], "-specs") == 0) 3547 { 3548 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3549 if (++i >= argc) 3550 fatal ("argument to `-specs' is missing"); 3551 3552 user->next = (struct user_specs *) 0; 3553 user->filename = argv[i]; 3554 if (user_specs_tail) 3555 user_specs_tail->next = user; 3556 else 3557 user_specs_head = user; 3558 user_specs_tail = user; 3559 } 3560 else if (strncmp (argv[i], "-specs=", 7) == 0) 3561 { 3562 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3563 if (strlen (argv[i]) == 7) 3564 fatal ("argument to `-specs=' is missing"); 3565 3566 user->next = (struct user_specs *) 0; 3567 user->filename = argv[i] + 7; 3568 if (user_specs_tail) 3569 user_specs_tail->next = user; 3570 else 3571 user_specs_head = user; 3572 user_specs_tail = user; 3573 } 3574 else if (strcmp (argv[i], "-time") == 0) 3575 report_times = 1; 3576 else if (strcmp (argv[i], "-pipe") == 0) 3577 { 3578 /* -pipe has to go into the switches array as well as 3579 setting a flag. */ 3580 use_pipes = 1; 3581 n_switches++; 3582 } 3583 else if (strcmp (argv[i], "-###") == 0) 3584 { 3585 /* This is similar to -v except that there is no execution 3586 of the commands and the echoed arguments are quoted. It 3587 is intended for use in shell scripts to capture the 3588 driver-generated command line. */ 3589 verbose_only_flag++; 3590 verbose_flag++; 3591 } 3592 else if (argv[i][0] == '-' && argv[i][1] != 0) 3593 { 3594 const char *p = &argv[i][1]; 3595 int c = *p; 3596 3597 switch (c) 3598 { 3599 case 'b': 3600 case 'V': 3601 fatal ("`-%c' must come at the start of the command line", c); 3602 break; 3603 3604 case 'B': 3605 { 3606 const char *value; 3607 int len; 3608 3609 if (p[1] == 0 && i + 1 == argc) 3610 fatal ("argument to `-B' is missing"); 3611 if (p[1] == 0) 3612 value = argv[++i]; 3613 else 3614 value = p + 1; 3615 3616 len = strlen (value); 3617 3618 /* Catch the case where the user has forgotten to append a 3619 directory separator to the path. Note, they may be using 3620 -B to add an executable name prefix, eg "i386-elf-", in 3621 order to distinguish between multiple installations of 3622 GCC in the same directory. Hence we must check to see 3623 if appending a directory separator actually makes a 3624 valid directory name. */ 3625 if (! IS_DIR_SEPARATOR (value [len - 1]) 3626 && is_directory (value, "", 0)) 3627 { 3628 char *tmp = xmalloc (len + 2); 3629 strcpy (tmp, value); 3630 tmp[len] = DIR_SEPARATOR; 3631 tmp[++ len] = 0; 3632 value = tmp; 3633 } 3634 3635 /* As a kludge, if the arg is "[foo/]stageN/", just 3636 add "[foo/]include" to the include prefix. */ 3637 if ((len == 7 3638 || (len > 7 3639 && (IS_DIR_SEPARATOR (value[len - 8])))) 3640 && strncmp (value + len - 7, "stage", 5) == 0 3641 && ISDIGIT (value[len - 2]) 3642 && (IS_DIR_SEPARATOR (value[len - 1]))) 3643 { 3644 if (len == 7) 3645 add_prefix (&include_prefixes, "include", NULL, 3646 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3647 else 3648 { 3649 char * string = xmalloc (len + 1); 3650 3651 strncpy (string, value, len - 7); 3652 strcpy (string + len - 7, "include"); 3653 add_prefix (&include_prefixes, string, NULL, 3654 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3655 } 3656 } 3657 3658 add_prefix (&exec_prefixes, value, NULL, 3659 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3660 add_prefix (&startfile_prefixes, value, NULL, 3661 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3662 add_prefix (&include_prefixes, concat (value, "include", NULL), 3663 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3664 n_switches++; 3665 } 3666 break; 3667 3668 case 'v': /* Print our subcommands and print versions. */ 3669 n_switches++; 3670 /* If they do anything other than exactly `-v', don't set 3671 verbose_flag; rather, continue on to give the error. */ 3672 if (p[1] != 0) 3673 break; 3674 verbose_flag++; 3675 break; 3676 3677 case 'S': 3678 case 'c': 3679 if (p[1] == 0) 3680 { 3681 have_c = 1; 3682 n_switches++; 3683 break; 3684 } 3685 goto normal_switch; 3686 3687 case 'o': 3688 have_o = 1; 3689#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 3690 if (! have_c) 3691 { 3692 int skip; 3693 3694 /* Forward scan, just in case -S or -c is specified 3695 after -o. */ 3696 int j = i + 1; 3697 if (p[1] == 0) 3698 ++j; 3699 while (j < argc) 3700 { 3701 if (argv[j][0] == '-') 3702 { 3703 if (SWITCH_CURTAILS_COMPILATION (argv[j][1]) 3704 && argv[j][2] == 0) 3705 { 3706 have_c = 1; 3707 break; 3708 } 3709 else if ((skip = SWITCH_TAKES_ARG (argv[j][1]))) 3710 j += skip - (argv[j][2] != 0); 3711 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))) 3712 j += skip; 3713 } 3714 j++; 3715 } 3716 } 3717#endif 3718#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX) 3719 if (p[1] == 0) 3720 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0); 3721 else 3722 argv[i] = convert_filename (argv[i], ! have_c, 0); 3723#endif 3724 goto normal_switch; 3725 3726 default: 3727 normal_switch: 3728 3729#ifdef MODIFY_TARGET_NAME 3730 is_modify_target_name = 0; 3731 3732 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3733 if (! strcmp (argv[i], modify_target[j].sw)) 3734 { 3735 char *new_name = xmalloc (strlen (modify_target[j].str) 3736 + strlen (spec_machine)); 3737 const char *p, *r; 3738 char *q; 3739 int made_addition = 0; 3740 3741 is_modify_target_name = 1; 3742 for (p = spec_machine, q = new_name; *p != 0; ) 3743 { 3744 if (modify_target[j].add_del == DELETE 3745 && (! strncmp (q, modify_target[j].str, 3746 strlen (modify_target[j].str)))) 3747 p += strlen (modify_target[j].str); 3748 else if (modify_target[j].add_del == ADD 3749 && ! made_addition && *p == '-') 3750 { 3751 for (r = modify_target[j].str; *r != 0; ) 3752 *q++ = *r++; 3753 made_addition = 1; 3754 } 3755 3756 *q++ = *p++; 3757 } 3758 3759 spec_machine = new_name; 3760 } 3761 3762 if (is_modify_target_name) 3763 break; 3764#endif 3765 3766 n_switches++; 3767 3768 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 3769 i += SWITCH_TAKES_ARG (c) - (p[1] != 0); 3770 else if (WORD_SWITCH_TAKES_ARG (p)) 3771 i += WORD_SWITCH_TAKES_ARG (p); 3772 } 3773 } 3774 else 3775 { 3776 n_infiles++; 3777 lang_n_infiles++; 3778 } 3779 } 3780 3781 combine_inputs = (have_c && have_o && lang_n_infiles > 1); 3782 3783 if ((save_temps_flag || report_times) && use_pipes) 3784 { 3785 /* -save-temps overrides -pipe, so that temp files are produced */ 3786 if (save_temps_flag) 3787 error ("warning: -pipe ignored because -save-temps specified"); 3788 /* -time overrides -pipe because we can't get correct stats when 3789 multiple children are running at once. */ 3790 else if (report_times) 3791 error ("warning: -pipe ignored because -time specified"); 3792 3793 use_pipes = 0; 3794 } 3795 3796 /* Set up the search paths before we go looking for config files. */ 3797 3798 /* These come before the md prefixes so that we will find gcc's subcommands 3799 (such as cpp) rather than those of the host system. */ 3800 /* Use 2 as fourth arg meaning try just the machine as a suffix, 3801 as well as trying the machine and the version. */ 3802#ifdef FREEBSD_NATIVE 3803 add_prefix (&exec_prefixes, PREFIX"/bin/", "BINUTILS", 3804 PREFIX_PRIORITY_LAST, 0, warn_std_ptr, 0); 3805#endif /* FREEBSD_NATIVE */ 3806#ifndef OS2 3807 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC", 3808 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3809 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS", 3810 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3811#ifndef FREEBSD_NATIVE 3812 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS", 3813 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3814 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS", 3815 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3816 add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS", 3817 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3818#endif /* FREEBSD_NATIVE */ 3819#endif 3820 3821#ifndef FREEBSD_NATIVE 3822 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS", 3823 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3824 add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS", 3825 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3826#endif /* not FREEBSD_NATIVE */ 3827 3828 tooldir_prefix = concat (tooldir_base_prefix, spec_machine, 3829 dir_separator_str, NULL); 3830 3831 /* If tooldir is relative, base it on exec_prefixes. A relative 3832 tooldir lets us move the installed tree as a unit. 3833 3834 If GCC_EXEC_PREFIX is defined, then we want to add two relative 3835 directories, so that we can search both the user specified directory 3836 and the standard place. */ 3837 3838 if (!IS_ABSOLUTE_PATH (tooldir_prefix)) 3839 { 3840 if (gcc_exec_prefix) 3841 { 3842 char *gcc_exec_tooldir_prefix 3843 = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 3844 spec_version, dir_separator_str, tooldir_prefix, NULL); 3845 3846 add_prefix (&exec_prefixes, 3847 concat (gcc_exec_tooldir_prefix, "bin", 3848 dir_separator_str, NULL), 3849 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3850 add_prefix (&startfile_prefixes, 3851 concat (gcc_exec_tooldir_prefix, "lib", 3852 dir_separator_str, NULL), 3853 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 3854 } 3855 3856 tooldir_prefix = concat (standard_exec_prefix, spec_machine, 3857 dir_separator_str, spec_version, 3858 dir_separator_str, tooldir_prefix, NULL); 3859 } 3860 3861#ifndef FREEBSD_NATIVE 3862 add_prefix (&exec_prefixes, 3863 concat (tooldir_prefix, "bin", dir_separator_str, NULL), 3864 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 0); 3865 add_prefix (&startfile_prefixes, 3866 concat (tooldir_prefix, "lib", dir_separator_str, NULL), 3867 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 3868 3869#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS) 3870 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix, 3871 then consider it to relocate with the rest of the GCC installation 3872 if GCC_EXEC_PREFIX is set. 3873 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */ 3874 if (target_system_root && gcc_exec_prefix) 3875 { 3876 char *tmp_prefix = make_relative_prefix (argv[0], 3877 standard_bindir_prefix, 3878 target_system_root); 3879 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0) 3880 { 3881 target_system_root = tmp_prefix; 3882 target_system_root_changed = 1; 3883 } 3884 } 3885#endif 3886#endif /* FREEBSD_NATIVE */ 3887 3888 /* More prefixes are enabled in main, after we read the specs file 3889 and determine whether this is cross-compilation or not. */ 3890 3891 /* Then create the space for the vectors and scan again. */ 3892 3893 switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr)); 3894 infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile)); 3895 n_switches = 0; 3896 n_infiles = 0; 3897 last_language_n_infiles = -1; 3898 3899 /* This, time, copy the text of each switch and store a pointer 3900 to the copy in the vector of switches. 3901 Store all the infiles in their vector. */ 3902 3903 for (i = 1; i < argc; i++) 3904 { 3905 /* Just skip the switches that were handled by the preceding loop. */ 3906#ifdef MODIFY_TARGET_NAME 3907 is_modify_target_name = 0; 3908 3909 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3910 if (! strcmp (argv[i], modify_target[j].sw)) 3911 is_modify_target_name = 1; 3912 3913 if (is_modify_target_name) 3914 ; 3915 else 3916#endif 3917 if (! strncmp (argv[i], "-Wa,", 4)) 3918 ; 3919 else if (! strncmp (argv[i], "-Wp,", 4)) 3920 ; 3921 else if (! strcmp (argv[i], "-pass-exit-codes")) 3922 ; 3923 else if (! strcmp (argv[i], "-print-search-dirs")) 3924 ; 3925 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3926 ; 3927 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3928 ; 3929 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3930 ; 3931 else if (! strcmp (argv[i], "-print-multi-lib")) 3932 ; 3933 else if (! strcmp (argv[i], "-print-multi-directory")) 3934 ; 3935 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3936 ; 3937 else if (! strcmp (argv[i], "-ftarget-help")) 3938 ; 3939 else if (! strcmp (argv[i], "-fhelp")) 3940 ; 3941 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3942 { 3943 /* Compensate for the +e options to the C++ front-end; 3944 they're there simply for cfront call-compatibility. We do 3945 some magic in default_compilers to pass them down properly. 3946 Note we deliberately start at the `+' here, to avoid passing 3947 -e0 or -e1 down into the linker. */ 3948 switches[n_switches].part1 = &argv[i][0]; 3949 switches[n_switches].args = 0; 3950 switches[n_switches].live_cond = SWITCH_OK; 3951 switches[n_switches].validated = 0; 3952 n_switches++; 3953 } 3954 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3955 { 3956 int prev, j; 3957 /* Split the argument at commas. */ 3958 prev = 4; 3959 for (j = 4; argv[i][j]; j++) 3960 if (argv[i][j] == ',') 3961 { 3962 infiles[n_infiles].language = "*"; 3963 infiles[n_infiles++].name 3964 = save_string (argv[i] + prev, j - prev); 3965 prev = j + 1; 3966 } 3967 /* Record the part after the last comma. */ 3968 infiles[n_infiles].language = "*"; 3969 infiles[n_infiles++].name = argv[i] + prev; 3970 } 3971 else if (strcmp (argv[i], "-Xlinker") == 0) 3972 { 3973 infiles[n_infiles].language = "*"; 3974 infiles[n_infiles++].name = argv[++i]; 3975 } 3976 else if (strcmp (argv[i], "-Xassembler") == 0) 3977 { 3978 infiles[n_infiles].language = "*"; 3979 infiles[n_infiles++].name = argv[++i]; 3980 } 3981 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3982 { 3983 infiles[n_infiles].language = "*"; 3984 infiles[n_infiles++].name = argv[++i]; 3985 } 3986 else if (strcmp (argv[i], "-l") == 0) 3987 { /* POSIX allows separation of -l and the lib arg; 3988 canonicalize by concatenating -l with its arg */ 3989 infiles[n_infiles].language = "*"; 3990 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL); 3991 } 3992 else if (strncmp (argv[i], "-l", 2) == 0) 3993 { 3994 infiles[n_infiles].language = "*"; 3995 infiles[n_infiles++].name = argv[i]; 3996 } 3997 else if (strcmp (argv[i], "-specs") == 0) 3998 i++; 3999 else if (strncmp (argv[i], "-specs=", 7) == 0) 4000 ; 4001 else if (strcmp (argv[i], "-time") == 0) 4002 ; 4003 else if (strcmp (argv[i], "-###") == 0) 4004 ; 4005 else if (argv[i][0] == '-' && argv[i][1] != 0) 4006 { 4007 const char *p = &argv[i][1]; 4008 int c = *p; 4009 4010 if (c == 'x') 4011 { 4012 if (p[1] == 0 && i + 1 == argc) 4013 fatal ("argument to `-x' is missing"); 4014 if (p[1] == 0) 4015 spec_lang = argv[++i]; 4016 else 4017 spec_lang = p + 1; 4018 if (! strcmp (spec_lang, "none")) 4019 /* Suppress the warning if -xnone comes after the last input 4020 file, because alternate command interfaces like g++ might 4021 find it useful to place -xnone after each input file. */ 4022 spec_lang = 0; 4023 else 4024 last_language_n_infiles = n_infiles; 4025 continue; 4026 } 4027 switches[n_switches].part1 = p; 4028 /* Deal with option arguments in separate argv elements. */ 4029 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0)) 4030 || WORD_SWITCH_TAKES_ARG (p)) 4031 { 4032 int j = 0; 4033 int n_args = WORD_SWITCH_TAKES_ARG (p); 4034 4035 if (n_args == 0) 4036 { 4037 /* Count only the option arguments in separate argv elements. */ 4038 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0); 4039 } 4040 if (i + n_args >= argc) 4041 fatal ("argument to `-%s' is missing", p); 4042 switches[n_switches].args 4043 = xmalloc ((n_args + 1) * sizeof(const char *)); 4044 while (j < n_args) 4045 switches[n_switches].args[j++] = argv[++i]; 4046 /* Null-terminate the vector. */ 4047 switches[n_switches].args[j] = 0; 4048 } 4049 else if (strchr (switches_need_spaces, c)) 4050 { 4051 /* On some systems, ld cannot handle some options without 4052 a space. So split the option from its argument. */ 4053 char *part1 = xmalloc (2); 4054 part1[0] = c; 4055 part1[1] = '\0'; 4056 4057 switches[n_switches].part1 = part1; 4058 switches[n_switches].args = xmalloc (2 * sizeof (const char *)); 4059 switches[n_switches].args[0] = xstrdup (p+1); 4060 switches[n_switches].args[1] = 0; 4061 } 4062 else 4063 switches[n_switches].args = 0; 4064 4065 switches[n_switches].live_cond = SWITCH_OK; 4066 switches[n_switches].validated = 0; 4067 switches[n_switches].ordering = 0; 4068 /* These are always valid, since gcc.c itself understands them. */ 4069 if (!strcmp (p, "save-temps") 4070 || !strcmp (p, "static-libgcc") 4071 || !strcmp (p, "shared-libgcc") 4072 || !strcmp (p, "pipe")) 4073 switches[n_switches].validated = 1; 4074 else 4075 { 4076 char ch = switches[n_switches].part1[0]; 4077 if (ch == 'B') 4078 switches[n_switches].validated = 1; 4079 } 4080 n_switches++; 4081 } 4082 else 4083 { 4084#ifdef HAVE_TARGET_OBJECT_SUFFIX 4085 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK)); 4086#endif 4087 4088 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0) 4089 { 4090 perror_with_name (argv[i]); 4091 error_count++; 4092 } 4093 else 4094 { 4095 infiles[n_infiles].language = spec_lang; 4096 infiles[n_infiles++].name = argv[i]; 4097 } 4098 } 4099 } 4100 4101 if (n_infiles == last_language_n_infiles && spec_lang != 0) 4102 error ("warning: `-x %s' after last input file has no effect", spec_lang); 4103 4104 /* Ensure we only invoke each subprocess once. */ 4105 if (target_help_flag || print_help_list) 4106 { 4107 n_infiles = 1; 4108 4109 /* Create a dummy input file, so that we can pass --target-help on to 4110 the various sub-processes. */ 4111 infiles[0].language = "c"; 4112 infiles[0].name = "help-dummy"; 4113 4114 if (target_help_flag) 4115 { 4116 switches[n_switches].part1 = "--target-help"; 4117 switches[n_switches].args = 0; 4118 switches[n_switches].live_cond = SWITCH_OK; 4119 switches[n_switches].validated = 0; 4120 4121 n_switches++; 4122 } 4123 4124 if (print_help_list) 4125 { 4126 switches[n_switches].part1 = "--help"; 4127 switches[n_switches].args = 0; 4128 switches[n_switches].live_cond = SWITCH_OK; 4129 switches[n_switches].validated = 0; 4130 4131 n_switches++; 4132 } 4133 } 4134 4135 switches[n_switches].part1 = 0; 4136 infiles[n_infiles].name = 0; 4137} 4138 4139/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS 4140 and place that in the environment. */ 4141 4142static void 4143set_collect_gcc_options (void) 4144{ 4145 int i; 4146 int first_time; 4147 4148 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to 4149 the compiler. */ 4150 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=", 4151 sizeof ("COLLECT_GCC_OPTIONS=") - 1); 4152 4153 first_time = TRUE; 4154 for (i = 0; (int) i < n_switches; i++) 4155 { 4156 const char *const *args; 4157 const char *p, *q; 4158 if (!first_time) 4159 obstack_grow (&collect_obstack, " ", 1); 4160 4161 first_time = FALSE; 4162 4163 /* Ignore elided switches. */ 4164 if (switches[i].live_cond == SWITCH_IGNORE) 4165 continue; 4166 4167 obstack_grow (&collect_obstack, "'-", 2); 4168 q = switches[i].part1; 4169 while ((p = strchr (q, '\''))) 4170 { 4171 obstack_grow (&collect_obstack, q, p - q); 4172 obstack_grow (&collect_obstack, "'\\''", 4); 4173 q = ++p; 4174 } 4175 obstack_grow (&collect_obstack, q, strlen (q)); 4176 obstack_grow (&collect_obstack, "'", 1); 4177 4178 for (args = switches[i].args; args && *args; args++) 4179 { 4180 obstack_grow (&collect_obstack, " '", 2); 4181 q = *args; 4182 while ((p = strchr (q, '\''))) 4183 { 4184 obstack_grow (&collect_obstack, q, p - q); 4185 obstack_grow (&collect_obstack, "'\\''", 4); 4186 q = ++p; 4187 } 4188 obstack_grow (&collect_obstack, q, strlen (q)); 4189 obstack_grow (&collect_obstack, "'", 1); 4190 } 4191 } 4192 obstack_grow (&collect_obstack, "\0", 1); 4193 putenv (obstack_finish (&collect_obstack)); 4194} 4195 4196/* Process a spec string, accumulating and running commands. */ 4197 4198/* These variables describe the input file name. 4199 input_file_number is the index on outfiles of this file, 4200 so that the output file name can be stored for later use by %o. 4201 input_basename is the start of the part of the input file 4202 sans all directory names, and basename_length is the number 4203 of characters starting there excluding the suffix .c or whatever. */ 4204 4205static const char *input_filename; 4206static int input_file_number; 4207size_t input_filename_length; 4208static int basename_length; 4209static int suffixed_basename_length; 4210static const char *input_basename; 4211static const char *input_suffix; 4212static struct stat input_stat; 4213static int input_stat_set; 4214 4215/* The compiler used to process the current input file. */ 4216static struct compiler *input_file_compiler; 4217 4218/* These are variables used within do_spec and do_spec_1. */ 4219 4220/* Nonzero if an arg has been started and not yet terminated 4221 (with space, tab or newline). */ 4222static int arg_going; 4223 4224/* Nonzero means %d or %g has been seen; the next arg to be terminated 4225 is a temporary file name. */ 4226static int delete_this_arg; 4227 4228/* Nonzero means %w has been seen; the next arg to be terminated 4229 is the output file name of this compilation. */ 4230static int this_is_output_file; 4231 4232/* Nonzero means %s has been seen; the next arg to be terminated 4233 is the name of a library file and we should try the standard 4234 search dirs for it. */ 4235static int this_is_library_file; 4236 4237/* Nonzero means that the input of this command is coming from a pipe. */ 4238static int input_from_pipe; 4239 4240/* Nonnull means substitute this for any suffix when outputting a switches 4241 arguments. */ 4242static const char *suffix_subst; 4243 4244/* Process the spec SPEC and run the commands specified therein. 4245 Returns 0 if the spec is successfully processed; -1 if failed. */ 4246 4247int 4248do_spec (const char *spec) 4249{ 4250 int value; 4251 4252 value = do_spec_2 (spec); 4253 4254 /* Force out any unfinished command. 4255 If -pipe, this forces out the last command if it ended in `|'. */ 4256 if (value == 0) 4257 { 4258 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4259 argbuf_index--; 4260 4261 set_collect_gcc_options (); 4262 4263 if (argbuf_index > 0) 4264 value = execute (); 4265 } 4266 4267 return value; 4268} 4269 4270static int 4271do_spec_2 (const char *spec) 4272{ 4273 const char *string; 4274 int result; 4275 4276 clear_args (); 4277 arg_going = 0; 4278 delete_this_arg = 0; 4279 this_is_output_file = 0; 4280 this_is_library_file = 0; 4281 input_from_pipe = 0; 4282 suffix_subst = NULL; 4283 4284 result = do_spec_1 (spec, 0, NULL); 4285 4286 /* End any pending argument. */ 4287 if (arg_going) 4288 { 4289 obstack_1grow (&obstack, 0); 4290 string = obstack_finish (&obstack); 4291 if (this_is_library_file) 4292 string = find_file (string); 4293 store_arg (string, delete_this_arg, this_is_output_file); 4294 if (this_is_output_file) 4295 outfiles[input_file_number] = string; 4296 arg_going = 0; 4297 } 4298 4299 return result; 4300} 4301 4302 4303/* Process the given spec string and add any new options to the end 4304 of the switches/n_switches array. */ 4305 4306static void 4307do_option_spec (const char *name, const char *spec) 4308{ 4309 unsigned int i, value_count, value_len; 4310 const char *p, *q, *value; 4311 char *tmp_spec, *tmp_spec_p; 4312 4313 if (configure_default_options[0].name == NULL) 4314 return; 4315 4316 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++) 4317 if (strcmp (configure_default_options[i].name, name) == 0) 4318 break; 4319 if (i == ARRAY_SIZE (configure_default_options)) 4320 return; 4321 4322 value = configure_default_options[i].value; 4323 value_len = strlen (value); 4324 4325 /* Compute the size of the final spec. */ 4326 value_count = 0; 4327 p = spec; 4328 while ((p = strstr (p, "%(VALUE)")) != NULL) 4329 { 4330 p ++; 4331 value_count ++; 4332 } 4333 4334 /* Replace each %(VALUE) by the specified value. */ 4335 tmp_spec = alloca (strlen (spec) + 1 4336 + value_count * (value_len - strlen ("%(VALUE)"))); 4337 tmp_spec_p = tmp_spec; 4338 q = spec; 4339 while ((p = strstr (q, "%(VALUE)")) != NULL) 4340 { 4341 memcpy (tmp_spec_p, q, p - q); 4342 tmp_spec_p = tmp_spec_p + (p - q); 4343 memcpy (tmp_spec_p, value, value_len); 4344 tmp_spec_p += value_len; 4345 q = p + strlen ("%(VALUE)"); 4346 } 4347 strcpy (tmp_spec_p, q); 4348 4349 do_self_spec (tmp_spec); 4350} 4351 4352/* Process the given spec string and add any new options to the end 4353 of the switches/n_switches array. */ 4354 4355static void 4356do_self_spec (const char *spec) 4357{ 4358 do_spec_2 (spec); 4359 do_spec_1 (" ", 0, NULL); 4360 4361 if (argbuf_index > 0) 4362 { 4363 int i, first; 4364 4365 first = n_switches; 4366 n_switches += argbuf_index; 4367 switches = xrealloc (switches, 4368 sizeof (struct switchstr) * (n_switches + 1)); 4369 4370 switches[n_switches] = switches[first]; 4371 for (i = 0; i < argbuf_index; i++) 4372 { 4373 struct switchstr *sw; 4374 4375 /* Each switch should start with '-'. */ 4376 if (argbuf[i][0] != '-') 4377 abort (); 4378 4379 sw = &switches[i + first]; 4380 sw->part1 = &argbuf[i][1]; 4381 sw->args = 0; 4382 sw->live_cond = SWITCH_OK; 4383 sw->validated = 0; 4384 sw->ordering = 0; 4385 } 4386 } 4387} 4388 4389/* Process the sub-spec SPEC as a portion of a larger spec. 4390 This is like processing a whole spec except that we do 4391 not initialize at the beginning and we do not supply a 4392 newline by default at the end. 4393 INSWITCH nonzero means don't process %-sequences in SPEC; 4394 in this case, % is treated as an ordinary character. 4395 This is used while substituting switches. 4396 INSWITCH nonzero also causes SPC not to terminate an argument. 4397 4398 Value is zero unless a line was finished 4399 and the command on that line reported an error. */ 4400 4401static int 4402do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part) 4403{ 4404 const char *p = spec; 4405 int c; 4406 int i; 4407 const char *string; 4408 int value; 4409 4410 while ((c = *p++)) 4411 /* If substituting a switch, treat all chars like letters. 4412 Otherwise, NL, SPC, TAB and % are special. */ 4413 switch (inswitch ? 'a' : c) 4414 { 4415 case '\n': 4416 /* End of line: finish any pending argument, 4417 then run the pending command if one has been started. */ 4418 if (arg_going) 4419 { 4420 obstack_1grow (&obstack, 0); 4421 string = obstack_finish (&obstack); 4422 if (this_is_library_file) 4423 string = find_file (string); 4424 store_arg (string, delete_this_arg, this_is_output_file); 4425 if (this_is_output_file) 4426 outfiles[input_file_number] = string; 4427 } 4428 arg_going = 0; 4429 4430 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4431 { 4432 /* A `|' before the newline means use a pipe here, 4433 but only if -pipe was specified. 4434 Otherwise, execute now and don't pass the `|' as an arg. */ 4435 if (use_pipes) 4436 { 4437 input_from_pipe = 1; 4438 break; 4439 } 4440 else 4441 argbuf_index--; 4442 } 4443 4444 set_collect_gcc_options (); 4445 4446 if (argbuf_index > 0) 4447 { 4448 value = execute (); 4449 if (value) 4450 return value; 4451 } 4452 /* Reinitialize for a new command, and for a new argument. */ 4453 clear_args (); 4454 arg_going = 0; 4455 delete_this_arg = 0; 4456 this_is_output_file = 0; 4457 this_is_library_file = 0; 4458 input_from_pipe = 0; 4459 break; 4460 4461 case '|': 4462 /* End any pending argument. */ 4463 if (arg_going) 4464 { 4465 obstack_1grow (&obstack, 0); 4466 string = obstack_finish (&obstack); 4467 if (this_is_library_file) 4468 string = find_file (string); 4469 store_arg (string, delete_this_arg, this_is_output_file); 4470 if (this_is_output_file) 4471 outfiles[input_file_number] = string; 4472 } 4473 4474 /* Use pipe */ 4475 obstack_1grow (&obstack, c); 4476 arg_going = 1; 4477 break; 4478 4479 case '\t': 4480 case ' ': 4481 /* Space or tab ends an argument if one is pending. */ 4482 if (arg_going) 4483 { 4484 obstack_1grow (&obstack, 0); 4485 string = obstack_finish (&obstack); 4486 if (this_is_library_file) 4487 string = find_file (string); 4488 store_arg (string, delete_this_arg, this_is_output_file); 4489 if (this_is_output_file) 4490 outfiles[input_file_number] = string; 4491 } 4492 /* Reinitialize for a new argument. */ 4493 arg_going = 0; 4494 delete_this_arg = 0; 4495 this_is_output_file = 0; 4496 this_is_library_file = 0; 4497 break; 4498 4499 case '%': 4500 switch (c = *p++) 4501 { 4502 case 0: 4503 fatal ("invalid specification! Bug in cc"); 4504 4505 case 'b': 4506 obstack_grow (&obstack, input_basename, basename_length); 4507 arg_going = 1; 4508 break; 4509 4510 case 'B': 4511 obstack_grow (&obstack, input_basename, suffixed_basename_length); 4512 arg_going = 1; 4513 break; 4514 4515 case 'd': 4516 delete_this_arg = 2; 4517 break; 4518 4519 /* Dump out the directories specified with LIBRARY_PATH, 4520 followed by the absolute directories 4521 that we search for startfiles. */ 4522 case 'D': 4523 { 4524 struct prefix_list *pl = startfile_prefixes.plist; 4525 size_t bufsize = 100; 4526 char *buffer = xmalloc (bufsize); 4527 int idx; 4528 4529 for (; pl; pl = pl->next) 4530 { 4531#ifdef RELATIVE_PREFIX_NOT_LINKDIR 4532 /* Used on systems which record the specified -L dirs 4533 and use them to search for dynamic linking. */ 4534 /* Relative directories always come from -B, 4535 and it is better not to use them for searching 4536 at run time. In particular, stage1 loses. */ 4537 if (!IS_ABSOLUTE_PATH (pl->prefix)) 4538 continue; 4539#endif 4540 /* Try subdirectory if there is one. */ 4541 if (multilib_dir != NULL 4542 || (pl->os_multilib && multilib_os_dir != NULL)) 4543 { 4544 const char *multi_dir; 4545 4546 multi_dir = pl->os_multilib ? multilib_os_dir 4547 : multilib_dir; 4548 if (machine_suffix && multilib_dir) 4549 { 4550 if (strlen (pl->prefix) + strlen (machine_suffix) 4551 >= bufsize) 4552 bufsize = (strlen (pl->prefix) 4553 + strlen (machine_suffix)) * 2 + 1; 4554 buffer = xrealloc (buffer, bufsize); 4555 strcpy (buffer, pl->prefix); 4556 strcat (buffer, machine_suffix); 4557 if (is_directory (buffer, multilib_dir, 1)) 4558 { 4559 do_spec_1 ("-L", 0, NULL); 4560#ifdef SPACE_AFTER_L_OPTION 4561 do_spec_1 (" ", 0, NULL); 4562#endif 4563 do_spec_1 (buffer, 1, NULL); 4564 do_spec_1 (multilib_dir, 1, NULL); 4565 /* Make this a separate argument. */ 4566 do_spec_1 (" ", 0, NULL); 4567 } 4568 } 4569 if (!pl->require_machine_suffix) 4570 { 4571 if (is_directory (pl->prefix, multi_dir, 1)) 4572 { 4573 do_spec_1 ("-L", 0, NULL); 4574#ifdef SPACE_AFTER_L_OPTION 4575 do_spec_1 (" ", 0, NULL); 4576#endif 4577 do_spec_1 (pl->prefix, 1, NULL); 4578 do_spec_1 (multi_dir, 1, NULL); 4579 /* Make this a separate argument. */ 4580 do_spec_1 (" ", 0, NULL); 4581 } 4582 } 4583 } 4584 if (machine_suffix) 4585 { 4586 if (is_directory (pl->prefix, machine_suffix, 1)) 4587 { 4588 do_spec_1 ("-L", 0, NULL); 4589#ifdef SPACE_AFTER_L_OPTION 4590 do_spec_1 (" ", 0, NULL); 4591#endif 4592 do_spec_1 (pl->prefix, 1, NULL); 4593 /* Remove slash from machine_suffix. */ 4594 if (strlen (machine_suffix) >= bufsize) 4595 bufsize = strlen (machine_suffix) * 2 + 1; 4596 buffer = xrealloc (buffer, bufsize); 4597 strcpy (buffer, machine_suffix); 4598 idx = strlen (buffer); 4599 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4600 buffer[idx - 1] = 0; 4601 do_spec_1 (buffer, 1, NULL); 4602 /* Make this a separate argument. */ 4603 do_spec_1 (" ", 0, NULL); 4604 } 4605 } 4606 if (!pl->require_machine_suffix) 4607 { 4608 if (is_directory (pl->prefix, "", 1)) 4609 { 4610 do_spec_1 ("-L", 0, NULL); 4611#ifdef SPACE_AFTER_L_OPTION 4612 do_spec_1 (" ", 0, NULL); 4613#endif 4614 /* Remove slash from pl->prefix. */ 4615 if (strlen (pl->prefix) >= bufsize) 4616 bufsize = strlen (pl->prefix) * 2 + 1; 4617 buffer = xrealloc (buffer, bufsize); 4618 strcpy (buffer, pl->prefix); 4619 idx = strlen (buffer); 4620 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4621 buffer[idx - 1] = 0; 4622 do_spec_1 (buffer, 1, NULL); 4623 /* Make this a separate argument. */ 4624 do_spec_1 (" ", 0, NULL); 4625 } 4626 } 4627 } 4628 free (buffer); 4629 } 4630 break; 4631 4632 case 'e': 4633 /* %efoo means report an error with `foo' as error message 4634 and don't execute any more commands for this file. */ 4635 { 4636 const char *q = p; 4637 char *buf; 4638 while (*p != 0 && *p != '\n') 4639 p++; 4640 buf = alloca (p - q + 1); 4641 strncpy (buf, q, p - q); 4642 buf[p - q] = 0; 4643 error ("%s", buf); 4644 return -1; 4645 } 4646 break; 4647 case 'n': 4648 /* %nfoo means report a notice with `foo' on stderr. */ 4649 { 4650 const char *q = p; 4651 char *buf; 4652 while (*p != 0 && *p != '\n') 4653 p++; 4654 buf = alloca (p - q + 1); 4655 strncpy (buf, q, p - q); 4656 buf[p - q] = 0; 4657 notice ("%s\n", buf); 4658 if (*p) 4659 p++; 4660 } 4661 break; 4662 4663 case 'j': 4664 { 4665 struct stat st; 4666 4667 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is 4668 defined, and it is not a directory, and it is 4669 writable, use it. Otherwise, treat this like any 4670 other temporary file. */ 4671 4672 if ((!save_temps_flag) 4673 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode)) 4674 && (access (HOST_BIT_BUCKET, W_OK) == 0)) 4675 { 4676 obstack_grow (&obstack, HOST_BIT_BUCKET, 4677 strlen (HOST_BIT_BUCKET)); 4678 delete_this_arg = 0; 4679 arg_going = 1; 4680 break; 4681 } 4682 } 4683 goto create_temp_file; 4684 case '|': 4685 if (use_pipes) 4686 { 4687 obstack_1grow (&obstack, '-'); 4688 delete_this_arg = 0; 4689 arg_going = 1; 4690 4691 /* consume suffix */ 4692 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4693 p++; 4694 if (p[0] == '%' && p[1] == 'O') 4695 p += 2; 4696 4697 break; 4698 } 4699 goto create_temp_file; 4700 case 'm': 4701 if (use_pipes) 4702 { 4703 /* consume suffix */ 4704 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4705 p++; 4706 if (p[0] == '%' && p[1] == 'O') 4707 p += 2; 4708 4709 break; 4710 } 4711 goto create_temp_file; 4712 case 'g': 4713 case 'u': 4714 case 'U': 4715 create_temp_file: 4716 { 4717 struct temp_name *t; 4718 int suffix_length; 4719 const char *suffix = p; 4720 char *saved_suffix = NULL; 4721 4722 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4723 p++; 4724 suffix_length = p - suffix; 4725 if (p[0] == '%' && p[1] == 'O') 4726 { 4727 p += 2; 4728 /* We don't support extra suffix characters after %O. */ 4729 if (*p == '.' || ISALPHA ((unsigned char) *p)) 4730 abort (); 4731 if (suffix_length == 0) 4732 suffix = TARGET_OBJECT_SUFFIX; 4733 else 4734 { 4735 saved_suffix 4736 = xmalloc (suffix_length 4737 + strlen (TARGET_OBJECT_SUFFIX)); 4738 strncpy (saved_suffix, suffix, suffix_length); 4739 strcpy (saved_suffix + suffix_length, 4740 TARGET_OBJECT_SUFFIX); 4741 } 4742 suffix_length += strlen (TARGET_OBJECT_SUFFIX); 4743 } 4744 4745 /* If the input_filename has the same suffix specified 4746 for the %g, %u, or %U, and -save-temps is specified, 4747 we could end up using that file as an intermediate 4748 thus clobbering the user's source file (.e.g., 4749 gcc -save-temps foo.s would clobber foo.s with the 4750 output of cpp0). So check for this condition and 4751 generate a temp file as the intermediate. */ 4752 4753 if (save_temps_flag) 4754 { 4755 temp_filename_length = basename_length + suffix_length; 4756 temp_filename = alloca (temp_filename_length + 1); 4757 strncpy ((char *) temp_filename, input_basename, basename_length); 4758 strncpy ((char *) temp_filename + basename_length, suffix, 4759 suffix_length); 4760 *((char *) temp_filename + temp_filename_length) = '\0'; 4761 if (strcmp (temp_filename, input_filename) != 0) 4762 { 4763 struct stat st_temp; 4764 4765 /* Note, set_input() resets input_stat_set to 0. */ 4766 if (input_stat_set == 0) 4767 { 4768 input_stat_set = stat (input_filename, &input_stat); 4769 if (input_stat_set >= 0) 4770 input_stat_set = 1; 4771 } 4772 4773 /* If we have the stat for the input_filename 4774 and we can do the stat for the temp_filename 4775 then the they could still refer to the same 4776 file if st_dev/st_ino's are the same. */ 4777 4778 if (input_stat_set != 1 4779 || stat (temp_filename, &st_temp) < 0 4780 || input_stat.st_dev != st_temp.st_dev 4781 || input_stat.st_ino != st_temp.st_ino) 4782 { 4783 temp_filename = save_string (temp_filename, 4784 temp_filename_length + 1); 4785 obstack_grow (&obstack, temp_filename, 4786 temp_filename_length); 4787 arg_going = 1; 4788 delete_this_arg = 0; 4789 break; 4790 } 4791 } 4792 } 4793 4794 /* See if we already have an association of %g/%u/%U and 4795 suffix. */ 4796 for (t = temp_names; t; t = t->next) 4797 if (t->length == suffix_length 4798 && strncmp (t->suffix, suffix, suffix_length) == 0 4799 && t->unique == (c == 'u' || c == 'U' || c == 'j')) 4800 break; 4801 4802 /* Make a new association if needed. %u and %j 4803 require one. */ 4804 if (t == 0 || c == 'u' || c == 'j') 4805 { 4806 if (t == 0) 4807 { 4808 t = xmalloc (sizeof (struct temp_name)); 4809 t->next = temp_names; 4810 temp_names = t; 4811 } 4812 t->length = suffix_length; 4813 if (saved_suffix) 4814 { 4815 t->suffix = saved_suffix; 4816 saved_suffix = NULL; 4817 } 4818 else 4819 t->suffix = save_string (suffix, suffix_length); 4820 t->unique = (c == 'u' || c == 'U' || c == 'j'); 4821 temp_filename = make_temp_file (t->suffix); 4822 temp_filename_length = strlen (temp_filename); 4823 t->filename = temp_filename; 4824 t->filename_length = temp_filename_length; 4825 } 4826 4827 if (saved_suffix) 4828 free (saved_suffix); 4829 4830 obstack_grow (&obstack, t->filename, t->filename_length); 4831 delete_this_arg = 1; 4832 } 4833 arg_going = 1; 4834 break; 4835 4836 case 'i': 4837 if (combine_inputs) 4838 { 4839 for (i = 0; (int) i < n_infiles; i++) 4840 store_arg (infiles[i].name, 0, 0); 4841 } 4842 else 4843 { 4844 obstack_grow (&obstack, input_filename, input_filename_length); 4845 arg_going = 1; 4846 } 4847 break; 4848 4849 case 'I': 4850 { 4851 struct prefix_list *pl = include_prefixes.plist; 4852 4853 if (gcc_exec_prefix) 4854 { 4855 do_spec_1 ("-iprefix", 1, NULL); 4856 /* Make this a separate argument. */ 4857 do_spec_1 (" ", 0, NULL); 4858 do_spec_1 (gcc_exec_prefix, 1, NULL); 4859 do_spec_1 (" ", 0, NULL); 4860 } 4861 4862 if (target_system_root_changed || 4863 (target_system_root && target_sysroot_hdrs_suffix)) 4864 { 4865 do_spec_1 ("-isysroot", 1, NULL); 4866 /* Make this a separate argument. */ 4867 do_spec_1 (" ", 0, NULL); 4868 do_spec_1 (target_system_root, 1, NULL); 4869 if (target_sysroot_hdrs_suffix) 4870 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL); 4871 do_spec_1 (" ", 0, NULL); 4872 } 4873 4874 for (; pl; pl = pl->next) 4875 { 4876 do_spec_1 ("-isystem", 1, NULL); 4877 /* Make this a separate argument. */ 4878 do_spec_1 (" ", 0, NULL); 4879 do_spec_1 (pl->prefix, 1, NULL); 4880 do_spec_1 (" ", 0, NULL); 4881 } 4882 } 4883 break; 4884 4885 case 'o': 4886 { 4887 int max = n_infiles; 4888 max += lang_specific_extra_outfiles; 4889 4890 for (i = 0; i < max; i++) 4891 if (outfiles[i]) 4892 store_arg (outfiles[i], 0, 0); 4893 break; 4894 } 4895 4896 case 'O': 4897 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 4898 arg_going = 1; 4899 break; 4900 4901 case 's': 4902 this_is_library_file = 1; 4903 break; 4904 4905 case 'V': 4906 outfiles[input_file_number] = NULL; 4907 break; 4908 4909 case 'w': 4910 this_is_output_file = 1; 4911 break; 4912 4913 case 'W': 4914 { 4915 int cur_index = argbuf_index; 4916 /* Handle the {...} following the %W. */ 4917 if (*p != '{') 4918 abort (); 4919 p = handle_braces (p + 1); 4920 if (p == 0) 4921 return -1; 4922 /* End any pending argument. */ 4923 if (arg_going) 4924 { 4925 obstack_1grow (&obstack, 0); 4926 string = obstack_finish (&obstack); 4927 if (this_is_library_file) 4928 string = find_file (string); 4929 store_arg (string, delete_this_arg, this_is_output_file); 4930 if (this_is_output_file) 4931 outfiles[input_file_number] = string; 4932 arg_going = 0; 4933 } 4934 /* If any args were output, mark the last one for deletion 4935 on failure. */ 4936 if (argbuf_index != cur_index) 4937 record_temp_file (argbuf[argbuf_index - 1], 0, 1); 4938 break; 4939 } 4940 4941 /* %x{OPTION} records OPTION for %X to output. */ 4942 case 'x': 4943 { 4944 const char *p1 = p; 4945 char *string; 4946 4947 /* Skip past the option value and make a copy. */ 4948 if (*p != '{') 4949 abort (); 4950 while (*p++ != '}') 4951 ; 4952 string = save_string (p1 + 1, p - p1 - 2); 4953 4954 /* See if we already recorded this option. */ 4955 for (i = 0; i < n_linker_options; i++) 4956 if (! strcmp (string, linker_options[i])) 4957 { 4958 free (string); 4959 return 0; 4960 } 4961 4962 /* This option is new; add it. */ 4963 add_linker_option (string, strlen (string)); 4964 } 4965 break; 4966 4967 /* Dump out the options accumulated previously using %x. */ 4968 case 'X': 4969 for (i = 0; i < n_linker_options; i++) 4970 { 4971 do_spec_1 (linker_options[i], 1, NULL); 4972 /* Make each accumulated option a separate argument. */ 4973 do_spec_1 (" ", 0, NULL); 4974 } 4975 break; 4976 4977 /* Dump out the options accumulated previously using -Wa,. */ 4978 case 'Y': 4979 for (i = 0; i < n_assembler_options; i++) 4980 { 4981 do_spec_1 (assembler_options[i], 1, NULL); 4982 /* Make each accumulated option a separate argument. */ 4983 do_spec_1 (" ", 0, NULL); 4984 } 4985 break; 4986 4987 /* Dump out the options accumulated previously using -Wp,. */ 4988 case 'Z': 4989 for (i = 0; i < n_preprocessor_options; i++) 4990 { 4991 do_spec_1 (preprocessor_options[i], 1, NULL); 4992 /* Make each accumulated option a separate argument. */ 4993 do_spec_1 (" ", 0, NULL); 4994 } 4995 break; 4996 4997 /* Here are digits and numbers that just process 4998 a certain constant string as a spec. */ 4999 5000 case '1': 5001 value = do_spec_1 (cc1_spec, 0, NULL); 5002 if (value != 0) 5003 return value; 5004 break; 5005 5006 case '2': 5007 value = do_spec_1 (cc1plus_spec, 0, NULL); 5008 if (value != 0) 5009 return value; 5010 break; 5011 5012 case 'a': 5013 value = do_spec_1 (asm_spec, 0, NULL); 5014 if (value != 0) 5015 return value; 5016 break; 5017 5018 case 'A': 5019 value = do_spec_1 (asm_final_spec, 0, NULL); 5020 if (value != 0) 5021 return value; 5022 break; 5023 5024 case 'C': 5025 { 5026 const char *const spec 5027 = (input_file_compiler->cpp_spec 5028 ? input_file_compiler->cpp_spec 5029 : cpp_spec); 5030 value = do_spec_1 (spec, 0, NULL); 5031 if (value != 0) 5032 return value; 5033 } 5034 break; 5035 5036 case 'E': 5037 value = do_spec_1 (endfile_spec, 0, NULL); 5038 if (value != 0) 5039 return value; 5040 break; 5041 5042 case 'l': 5043 value = do_spec_1 (link_spec, 0, NULL); 5044 if (value != 0) 5045 return value; 5046 break; 5047 5048 case 'L': 5049 value = do_spec_1 (lib_spec, 0, NULL); 5050 if (value != 0) 5051 return value; 5052 break; 5053 5054 case 'G': 5055 value = do_spec_1 (libgcc_spec, 0, NULL); 5056 if (value != 0) 5057 return value; 5058 break; 5059 5060 case 'M': 5061 if (multilib_dir && strcmp (multilib_dir, ".") != 0) 5062 { 5063 char *p; 5064 const char *q; 5065 size_t len; 5066 5067 len = strlen (multilib_dir); 5068 obstack_blank (&obstack, len + 1); 5069 p = obstack_next_free (&obstack) - (len + 1); 5070 5071 *p++ = '_'; 5072 for (q = multilib_dir; *q ; ++q, ++p) 5073 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q); 5074 } 5075 break; 5076 5077 case 'R': 5078 /* We assume there is a directory 5079 separator at the end of this string. */ 5080 if (target_system_root) 5081 { 5082 obstack_grow (&obstack, target_system_root, 5083 strlen (target_system_root)); 5084 if (target_sysroot_suffix) 5085 obstack_grow (&obstack, target_sysroot_suffix, 5086 strlen (target_sysroot_suffix)); 5087 } 5088 break; 5089 5090 case 'S': 5091 value = do_spec_1 (startfile_spec, 0, NULL); 5092 if (value != 0) 5093 return value; 5094 break; 5095 5096 /* Here we define characters other than letters and digits. */ 5097 5098 case '{': 5099 p = handle_braces (p); 5100 if (p == 0) 5101 return -1; 5102 break; 5103 5104 case ':': 5105 p = handle_spec_function (p); 5106 if (p == 0) 5107 return -1; 5108 break; 5109 5110 case '%': 5111 obstack_1grow (&obstack, '%'); 5112 break; 5113 5114 case '.': 5115 { 5116 unsigned len = 0; 5117 5118 while (p[len] && p[len] != ' ' && p[len] != '%') 5119 len++; 5120 suffix_subst = save_string (p - 1, len + 1); 5121 p += len; 5122 } 5123 break; 5124 5125 /* Henceforth ignore the option(s) matching the pattern 5126 after the %<. */ 5127 case '<': 5128 { 5129 unsigned len = 0; 5130 int have_wildcard = 0; 5131 int i; 5132 5133 while (p[len] && p[len] != ' ' && p[len] != '\t') 5134 len++; 5135 5136 if (p[len-1] == '*') 5137 have_wildcard = 1; 5138 5139 for (i = 0; i < n_switches; i++) 5140 if (!strncmp (switches[i].part1, p, len - have_wildcard) 5141 && (have_wildcard || switches[i].part1[len] == '\0')) 5142 { 5143 switches[i].live_cond = SWITCH_IGNORE; 5144 switches[i].validated = 1; 5145 } 5146 5147 p += len; 5148 } 5149 break; 5150 5151 case '*': 5152 if (soft_matched_part) 5153 { 5154 do_spec_1 (soft_matched_part, 1, NULL); 5155 do_spec_1 (" ", 0, NULL); 5156 } 5157 else 5158 /* Catch the case where a spec string contains something like 5159 '%{foo:%*}'. ie there is no * in the pattern on the left 5160 hand side of the :. */ 5161 error ("spec failure: '%%*' has not been initialized by pattern match"); 5162 break; 5163 5164 /* Process a string found as the value of a spec given by name. 5165 This feature allows individual machine descriptions 5166 to add and use their own specs. 5167 %[...] modifies -D options the way %P does; 5168 %(...) uses the spec unmodified. */ 5169 case '[': 5170 error ("warning: use of obsolete %%[ operator in specs"); 5171 case '(': 5172 { 5173 const char *name = p; 5174 struct spec_list *sl; 5175 int len; 5176 5177 /* The string after the S/P is the name of a spec that is to be 5178 processed. */ 5179 while (*p && *p != ')' && *p != ']') 5180 p++; 5181 5182 /* See if it's in the list. */ 5183 for (len = p - name, sl = specs; sl; sl = sl->next) 5184 if (sl->name_len == len && !strncmp (sl->name, name, len)) 5185 { 5186 name = *(sl->ptr_spec); 5187#ifdef DEBUG_SPECS 5188 notice ("Processing spec %c%s%c, which is '%s'\n", 5189 c, sl->name, (c == '(') ? ')' : ']', name); 5190#endif 5191 break; 5192 } 5193 5194 if (sl) 5195 { 5196 if (c == '(') 5197 { 5198 value = do_spec_1 (name, 0, NULL); 5199 if (value != 0) 5200 return value; 5201 } 5202 else 5203 { 5204 char *x = alloca (strlen (name) * 2 + 1); 5205 char *buf = x; 5206 const char *y = name; 5207 int flag = 0; 5208 5209 /* Copy all of NAME into BUF, but put __ after 5210 every -D and at the end of each arg. */ 5211 while (1) 5212 { 5213 if (! strncmp (y, "-D", 2)) 5214 { 5215 *x++ = '-'; 5216 *x++ = 'D'; 5217 *x++ = '_'; 5218 *x++ = '_'; 5219 y += 2; 5220 flag = 1; 5221 continue; 5222 } 5223 else if (flag 5224 && (*y == ' ' || *y == '\t' || *y == '=' 5225 || *y == '}' || *y == 0)) 5226 { 5227 *x++ = '_'; 5228 *x++ = '_'; 5229 flag = 0; 5230 } 5231 if (*y == 0) 5232 break; 5233 else 5234 *x++ = *y++; 5235 } 5236 *x = 0; 5237 5238 value = do_spec_1 (buf, 0, NULL); 5239 if (value != 0) 5240 return value; 5241 } 5242 } 5243 5244 /* Discard the closing paren or bracket. */ 5245 if (*p) 5246 p++; 5247 } 5248 break; 5249 5250 default: 5251 error ("spec failure: unrecognized spec option '%c'", c); 5252 break; 5253 } 5254 break; 5255 5256 case '\\': 5257 /* Backslash: treat next character as ordinary. */ 5258 c = *p++; 5259 5260 /* Fall through. */ 5261 default: 5262 /* Ordinary character: put it into the current argument. */ 5263 obstack_1grow (&obstack, c); 5264 arg_going = 1; 5265 } 5266 5267 /* End of string. If we are processing a spec function, we need to 5268 end any pending argument. */ 5269 if (processing_spec_function && arg_going) 5270 { 5271 obstack_1grow (&obstack, 0); 5272 string = obstack_finish (&obstack); 5273 if (this_is_library_file) 5274 string = find_file (string); 5275 store_arg (string, delete_this_arg, this_is_output_file); 5276 if (this_is_output_file) 5277 outfiles[input_file_number] = string; 5278 arg_going = 0; 5279 } 5280 5281 return 0; 5282} 5283 5284/* Look up a spec function. */ 5285 5286static const struct spec_function * 5287lookup_spec_function (const char *name) 5288{ 5289 static const struct spec_function * const spec_function_tables[] = 5290 { 5291 static_spec_functions, 5292 lang_specific_spec_functions, 5293 }; 5294 const struct spec_function *sf; 5295 unsigned int i; 5296 5297 for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++) 5298 { 5299 for (sf = spec_function_tables[i]; sf->name != NULL; sf++) 5300 if (strcmp (sf->name, name) == 0) 5301 return sf; 5302 } 5303 5304 return NULL; 5305} 5306 5307/* Evaluate a spec function. */ 5308 5309static const char * 5310eval_spec_function (const char *func, const char *args) 5311{ 5312 const struct spec_function *sf; 5313 const char *funcval; 5314 5315 /* Saved spec processing context. */ 5316 int save_argbuf_index; 5317 int save_argbuf_length; 5318 const char **save_argbuf; 5319 5320 int save_arg_going; 5321 int save_delete_this_arg; 5322 int save_this_is_output_file; 5323 int save_this_is_library_file; 5324 int save_input_from_pipe; 5325 const char *save_suffix_subst; 5326 5327 5328 sf = lookup_spec_function (func); 5329 if (sf == NULL) 5330 fatal ("unknown spec function `%s'", func); 5331 5332 /* Push the spec processing context. */ 5333 save_argbuf_index = argbuf_index; 5334 save_argbuf_length = argbuf_length; 5335 save_argbuf = argbuf; 5336 5337 save_arg_going = arg_going; 5338 save_delete_this_arg = delete_this_arg; 5339 save_this_is_output_file = this_is_output_file; 5340 save_this_is_library_file = this_is_library_file; 5341 save_input_from_pipe = input_from_pipe; 5342 save_suffix_subst = suffix_subst; 5343 5344 /* Create a new spec processing context, and build the function 5345 arguments. */ 5346 5347 alloc_args (); 5348 if (do_spec_2 (args) < 0) 5349 fatal ("error in args to spec function `%s'", func); 5350 5351 /* argbuf_index is an index for the next argument to be inserted, and 5352 so contains the count of the args already inserted. */ 5353 5354 funcval = (*sf->func) (argbuf_index, argbuf); 5355 5356 /* Pop the spec processing context. */ 5357 argbuf_index = save_argbuf_index; 5358 argbuf_length = save_argbuf_length; 5359 free (argbuf); 5360 argbuf = save_argbuf; 5361 5362 arg_going = save_arg_going; 5363 delete_this_arg = save_delete_this_arg; 5364 this_is_output_file = save_this_is_output_file; 5365 this_is_library_file = save_this_is_library_file; 5366 input_from_pipe = save_input_from_pipe; 5367 suffix_subst = save_suffix_subst; 5368 5369 return funcval; 5370} 5371 5372/* Handle a spec function call of the form: 5373 5374 %:function(args) 5375 5376 ARGS is processed as a spec in a separate context and split into an 5377 argument vector in the normal fashion. The function returns a string 5378 containing a spec which we then process in the caller's context, or 5379 NULL if no processing is required. */ 5380 5381static const char * 5382handle_spec_function (const char *p) 5383{ 5384 char *func, *args; 5385 const char *endp, *funcval; 5386 int count; 5387 5388 processing_spec_function++; 5389 5390 /* Get the function name. */ 5391 for (endp = p; *endp != '\0'; endp++) 5392 { 5393 if (*endp == '(') /* ) */ 5394 break; 5395 /* Only allow [A-Za-z0-9], -, and _ in function names. */ 5396 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_')) 5397 fatal ("malformed spec function name"); 5398 } 5399 if (*endp != '(') /* ) */ 5400 fatal ("no arguments for spec function"); 5401 func = save_string (p, endp - p); 5402 p = ++endp; 5403 5404 /* Get the arguments. */ 5405 for (count = 0; *endp != '\0'; endp++) 5406 { 5407 /* ( */ 5408 if (*endp == ')') 5409 { 5410 if (count == 0) 5411 break; 5412 count--; 5413 } 5414 else if (*endp == '(') /* ) */ 5415 count++; 5416 } 5417 /* ( */ 5418 if (*endp != ')') 5419 fatal ("malformed spec function arguments"); 5420 args = save_string (p, endp - p); 5421 p = ++endp; 5422 5423 /* p now points to just past the end of the spec function expression. */ 5424 5425 funcval = eval_spec_function (func, args); 5426 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0) 5427 p = NULL; 5428 5429 free (func); 5430 free (args); 5431 5432 processing_spec_function--; 5433 5434 return p; 5435} 5436 5437/* Inline subroutine of handle_braces. Returns true if the current 5438 input suffix matches the atom bracketed by ATOM and END_ATOM. */ 5439static inline bool 5440input_suffix_matches (const char *atom, const char *end_atom) 5441{ 5442 return (input_suffix 5443 && !strncmp (input_suffix, atom, end_atom - atom) 5444 && input_suffix[end_atom - atom] == '\0'); 5445} 5446 5447/* Inline subroutine of handle_braces. Returns true if a switch 5448 matching the atom bracketed by ATOM and END_ATOM appeared on the 5449 command line. */ 5450static inline bool 5451switch_matches (const char *atom, const char *end_atom, int starred) 5452{ 5453 int i; 5454 int len = end_atom - atom; 5455 int plen = starred ? len : -1; 5456 5457 for (i = 0; i < n_switches; i++) 5458 if (!strncmp (switches[i].part1, atom, len) 5459 && (starred || switches[i].part1[len] == '\0') 5460 && check_live_switch (i, plen)) 5461 return true; 5462 5463 return false; 5464} 5465 5466/* Inline subroutine of handle_braces. Mark all of the switches which 5467 match ATOM (extends to END_ATOM; STARRED indicates whether there 5468 was a star after the atom) for later processing. */ 5469static inline void 5470mark_matching_switches (const char *atom, const char *end_atom, int starred) 5471{ 5472 int i; 5473 int len = end_atom - atom; 5474 int plen = starred ? len : -1; 5475 5476 for (i = 0; i < n_switches; i++) 5477 if (!strncmp (switches[i].part1, atom, len) 5478 && (starred || switches[i].part1[len] == '\0') 5479 && check_live_switch (i, plen)) 5480 switches[i].ordering = 1; 5481} 5482 5483/* Inline subroutine of handle_braces. Process all the currently 5484 marked switches through give_switch, and clear the marks. */ 5485static inline void 5486process_marked_switches (void) 5487{ 5488 int i; 5489 5490 for (i = 0; i < n_switches; i++) 5491 if (switches[i].ordering == 1) 5492 { 5493 switches[i].ordering = 0; 5494 give_switch (i, 0); 5495 } 5496} 5497 5498/* Handle a %{ ... } construct. P points just inside the leading {. 5499 Returns a pointer one past the end of the brace block, or 0 5500 if we call do_spec_1 and that returns -1. */ 5501 5502static const char * 5503handle_braces (const char *p) 5504{ 5505 const char *atom, *end_atom; 5506 const char *d_atom = NULL, *d_end_atom = NULL; 5507 5508 bool a_is_suffix; 5509 bool a_is_starred; 5510 bool a_is_negated; 5511 bool a_matched; 5512 5513 bool a_must_be_last = false; 5514 bool ordered_set = false; 5515 bool disjunct_set = false; 5516 bool disj_matched = false; 5517 bool disj_starred = true; 5518 bool n_way_choice = false; 5519 bool n_way_matched = false; 5520 5521#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 5522 5523 do 5524 { 5525 if (a_must_be_last) 5526 abort (); 5527 5528 /* Scan one "atom" (S in the description above of %{}, possibly 5529 with !, ., or * modifiers). */ 5530 a_matched = a_is_suffix = a_is_starred = a_is_negated = false; 5531 5532 SKIP_WHITE(); 5533 if (*p == '!') 5534 p++, a_is_negated = true; 5535 5536 SKIP_WHITE(); 5537 if (*p == '.') 5538 p++, a_is_suffix = true; 5539 5540 atom = p; 5541 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '=' 5542 || *p == ',' || *p == '.' || *p == '@') 5543 p++; 5544 end_atom = p; 5545 5546 if (*p == '*') 5547 p++, a_is_starred = 1; 5548 5549 SKIP_WHITE(); 5550 if (*p == '&' || *p == '}') 5551 { 5552 /* Substitute the switch(es) indicated by the current atom. */ 5553 ordered_set = true; 5554 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix 5555 || atom == end_atom) 5556 abort (); 5557 5558 mark_matching_switches (atom, end_atom, a_is_starred); 5559 5560 if (*p == '}') 5561 process_marked_switches (); 5562 } 5563 else if (*p == '|' || *p == ':') 5564 { 5565 /* Substitute some text if the current atom appears as a switch 5566 or suffix. */ 5567 disjunct_set = true; 5568 if (ordered_set) 5569 abort (); 5570 5571 if (atom == end_atom) 5572 { 5573 if (!n_way_choice || disj_matched || *p == '|' 5574 || a_is_negated || a_is_suffix || a_is_starred) 5575 abort (); 5576 5577 /* An empty term may appear as the last choice of an 5578 N-way choice set; it means "otherwise". */ 5579 a_must_be_last = true; 5580 disj_matched = !n_way_matched; 5581 disj_starred = false; 5582 } 5583 else 5584 { 5585 if (a_is_suffix && a_is_starred) 5586 abort (); 5587 5588 if (!a_is_starred) 5589 disj_starred = false; 5590 5591 /* Don't bother testing this atom if we already have a 5592 match. */ 5593 if (!disj_matched && !n_way_matched) 5594 { 5595 if (a_is_suffix) 5596 a_matched = input_suffix_matches (atom, end_atom); 5597 else 5598 a_matched = switch_matches (atom, end_atom, a_is_starred); 5599 5600 if (a_matched != a_is_negated) 5601 { 5602 disj_matched = true; 5603 d_atom = atom; 5604 d_end_atom = end_atom; 5605 } 5606 } 5607 } 5608 5609 if (*p == ':') 5610 { 5611 /* Found the body, that is, the text to substitute if the 5612 current disjunction matches. */ 5613 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred, 5614 disj_matched && !n_way_matched); 5615 if (p == 0) 5616 return 0; 5617 5618 /* If we have an N-way choice, reset state for the next 5619 disjunction. */ 5620 if (*p == ';') 5621 { 5622 n_way_choice = true; 5623 n_way_matched |= disj_matched; 5624 disj_matched = false; 5625 disj_starred = true; 5626 d_atom = d_end_atom = NULL; 5627 } 5628 } 5629 } 5630 else 5631 abort (); 5632 } 5633 while (*p++ != '}'); 5634 5635 return p; 5636 5637#undef SKIP_WHITE 5638} 5639 5640/* Subroutine of handle_braces. Scan and process a brace substitution body 5641 (X in the description of %{} syntax). P points one past the colon; 5642 ATOM and END_ATOM bracket the first atom which was found to be true 5643 (present) in the current disjunction; STARRED indicates whether all 5644 the atoms in the current disjunction were starred (for syntax validation); 5645 MATCHED indicates whether the disjunction matched or not, and therefore 5646 whether or not the body is to be processed through do_spec_1 or just 5647 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1 5648 returns -1. */ 5649 5650static const char * 5651process_brace_body (const char *p, const char *atom, const char *end_atom, 5652 int starred, int matched) 5653{ 5654 const char *body, *end_body; 5655 unsigned int nesting_level; 5656 bool have_subst = false; 5657 5658 /* Locate the closing } or ;, honoring nested braces. 5659 Trim trailing whitespace. */ 5660 body = p; 5661 nesting_level = 1; 5662 for (;;) 5663 { 5664 if (*p == '{') 5665 nesting_level++; 5666 else if (*p == '}') 5667 { 5668 if (!--nesting_level) 5669 break; 5670 } 5671 else if (*p == ';' && nesting_level == 1) 5672 break; 5673 else if (*p == '%' && p[1] == '*' && nesting_level == 1) 5674 have_subst = true; 5675 else if (*p == '\0') 5676 abort (); 5677 p++; 5678 } 5679 5680 end_body = p; 5681 while (end_body[-1] == ' ' || end_body[-1] == '\t') 5682 end_body--; 5683 5684 if (have_subst && !starred) 5685 abort (); 5686 5687 if (matched) 5688 { 5689 /* Copy the substitution body to permanent storage and execute it. 5690 If have_subst is false, this is a simple matter of running the 5691 body through do_spec_1... */ 5692 char *string = save_string (body, end_body - body); 5693 if (!have_subst) 5694 { 5695 if (do_spec_1 (string, 0, NULL) < 0) 5696 return 0; 5697 } 5698 else 5699 { 5700 /* ... but if have_subst is true, we have to process the 5701 body once for each matching switch, with %* set to the 5702 variant part of the switch. */ 5703 unsigned int hard_match_len = end_atom - atom; 5704 int i; 5705 5706 for (i = 0; i < n_switches; i++) 5707 if (!strncmp (switches[i].part1, atom, hard_match_len) 5708 && check_live_switch (i, hard_match_len)) 5709 { 5710 if (do_spec_1 (string, 0, 5711 &switches[i].part1[hard_match_len]) < 0) 5712 return 0; 5713 /* Pass any arguments this switch has. */ 5714 give_switch (i, 1); 5715 suffix_subst = NULL; 5716 } 5717 } 5718 } 5719 5720 return p; 5721} 5722 5723/* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch 5724 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*} 5725 spec, or -1 if either exact match or %* is used. 5726 5727 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch 5728 whose value does not begin with "no-" is obsoleted by the same value 5729 with the "no-", similarly for a switch with the "no-" prefix. */ 5730 5731static int 5732check_live_switch (int switchnum, int prefix_length) 5733{ 5734 const char *name = switches[switchnum].part1; 5735 int i; 5736 5737 /* In the common case of {<at-most-one-letter>*}, a negating 5738 switch would always match, so ignore that case. We will just 5739 send the conflicting switches to the compiler phase. */ 5740 if (prefix_length >= 0 && prefix_length <= 1) 5741 return 1; 5742 5743 /* If we already processed this switch and determined if it was 5744 live or not, return our past determination. */ 5745 if (switches[switchnum].live_cond != 0) 5746 return switches[switchnum].live_cond > 0; 5747 5748 /* Now search for duplicate in a manner that depends on the name. */ 5749 switch (*name) 5750 { 5751 case 'O': 5752 for (i = switchnum + 1; i < n_switches; i++) 5753 if (switches[i].part1[0] == 'O') 5754 { 5755 switches[switchnum].validated = 1; 5756 switches[switchnum].live_cond = SWITCH_FALSE; 5757 return 0; 5758 } 5759 break; 5760 5761 case 'W': case 'f': case 'm': 5762 if (! strncmp (name + 1, "no-", 3)) 5763 { 5764 /* We have Xno-YYY, search for XYYY. */ 5765 for (i = switchnum + 1; i < n_switches; i++) 5766 if (switches[i].part1[0] == name[0] 5767 && ! strcmp (&switches[i].part1[1], &name[4])) 5768 { 5769 switches[switchnum].validated = 1; 5770 switches[switchnum].live_cond = SWITCH_FALSE; 5771 return 0; 5772 } 5773 } 5774 else 5775 { 5776 /* We have XYYY, search for Xno-YYY. */ 5777 for (i = switchnum + 1; i < n_switches; i++) 5778 if (switches[i].part1[0] == name[0] 5779 && switches[i].part1[1] == 'n' 5780 && switches[i].part1[2] == 'o' 5781 && switches[i].part1[3] == '-' 5782 && !strcmp (&switches[i].part1[4], &name[1])) 5783 { 5784 switches[switchnum].validated = 1; 5785 switches[switchnum].live_cond = SWITCH_FALSE; 5786 return 0; 5787 } 5788 } 5789 break; 5790 } 5791 5792 /* Otherwise the switch is live. */ 5793 switches[switchnum].live_cond = SWITCH_LIVE; 5794 return 1; 5795} 5796 5797/* Pass a switch to the current accumulating command 5798 in the same form that we received it. 5799 SWITCHNUM identifies the switch; it is an index into 5800 the vector of switches gcc received, which is `switches'. 5801 This cannot fail since it never finishes a command line. 5802 5803 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */ 5804 5805static void 5806give_switch (int switchnum, int omit_first_word) 5807{ 5808 if (switches[switchnum].live_cond == SWITCH_IGNORE) 5809 return; 5810 5811 if (!omit_first_word) 5812 { 5813 do_spec_1 ("-", 0, NULL); 5814 do_spec_1 (switches[switchnum].part1, 1, NULL); 5815 } 5816 5817 if (switches[switchnum].args != 0) 5818 { 5819 const char **p; 5820 for (p = switches[switchnum].args; *p; p++) 5821 { 5822 const char *arg = *p; 5823 5824 do_spec_1 (" ", 0, NULL); 5825 if (suffix_subst) 5826 { 5827 unsigned length = strlen (arg); 5828 int dot = 0; 5829 5830 while (length-- && !IS_DIR_SEPARATOR (arg[length])) 5831 if (arg[length] == '.') 5832 { 5833 ((char *)arg)[length] = 0; 5834 dot = 1; 5835 break; 5836 } 5837 do_spec_1 (arg, 1, NULL); 5838 if (dot) 5839 ((char *)arg)[length] = '.'; 5840 do_spec_1 (suffix_subst, 1, NULL); 5841 } 5842 else 5843 do_spec_1 (arg, 1, NULL); 5844 } 5845 } 5846 5847 do_spec_1 (" ", 0, NULL); 5848 switches[switchnum].validated = 1; 5849} 5850 5851/* Search for a file named NAME trying various prefixes including the 5852 user's -B prefix and some standard ones. 5853 Return the absolute file name found. If nothing is found, return NAME. */ 5854 5855static const char * 5856find_file (const char *name) 5857{ 5858 char *newname; 5859 5860 /* Try multilib_dir if it is defined. */ 5861 if (multilib_os_dir != NULL) 5862 { 5863 newname = find_a_file (&startfile_prefixes, name, R_OK, 1); 5864 5865 /* If we don't find it in the multi library dir, then fall 5866 through and look for it in the normal places. */ 5867 if (newname != NULL) 5868 return newname; 5869 } 5870 5871 newname = find_a_file (&startfile_prefixes, name, R_OK, 0); 5872 return newname ? newname : name; 5873} 5874 5875/* Determine whether a directory exists. If LINKER, return 0 for 5876 certain fixed names not needed by the linker. If not LINKER, it is 5877 only important to return 0 if the host machine has a small ARG_MAX 5878 limit. */ 5879 5880static int 5881is_directory (const char *path1, const char *path2, int linker) 5882{ 5883 int len1 = strlen (path1); 5884 int len2 = strlen (path2); 5885 char *path = alloca (3 + len1 + len2); 5886 char *cp; 5887 struct stat st; 5888 5889#ifndef SMALL_ARG_MAX 5890 if (! linker) 5891 return 1; 5892#endif 5893 5894 /* Construct the path from the two parts. Ensure the string ends with "/.". 5895 The resulting path will be a directory even if the given path is a 5896 symbolic link. */ 5897 memcpy (path, path1, len1); 5898 memcpy (path + len1, path2, len2); 5899 cp = path + len1 + len2; 5900 if (!IS_DIR_SEPARATOR (cp[-1])) 5901 *cp++ = DIR_SEPARATOR; 5902 *cp++ = '.'; 5903 *cp = '\0'; 5904 5905#ifndef FREEBSD_NATIVE 5906 /* Exclude directories that the linker is known to search. */ 5907 if (linker 5908 && ((cp - path == 6 5909 && strcmp (path, concat (dir_separator_str, "lib", 5910 dir_separator_str, ".", NULL)) == 0) 5911 || (cp - path == 10 5912 && strcmp (path, concat (dir_separator_str, "usr", 5913 dir_separator_str, "lib", 5914 dir_separator_str, ".", NULL)) == 0))) 5915 return 0; 5916#endif /* FREEBSD_NATIVE */ 5917 5918 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode)); 5919} 5920 5921/* Set up the various global variables to indicate that we're processing 5922 the input file named FILENAME. */ 5923 5924void 5925set_input (const char *filename) 5926{ 5927 const char *p; 5928 5929 input_filename = filename; 5930 input_filename_length = strlen (input_filename); 5931 5932 input_basename = input_filename; 5933#ifdef HAVE_DOS_BASED_FILE_SYSTEM 5934 /* Skip drive name so 'x:foo' is handled properly. */ 5935 if (input_basename[1] == ':') 5936 input_basename += 2; 5937#endif 5938 for (p = input_basename; *p; p++) 5939 if (IS_DIR_SEPARATOR (*p)) 5940 input_basename = p + 1; 5941 5942 /* Find a suffix starting with the last period, 5943 and set basename_length to exclude that suffix. */ 5944 basename_length = strlen (input_basename); 5945 suffixed_basename_length = basename_length; 5946 p = input_basename + basename_length; 5947 while (p != input_basename && *p != '.') 5948 --p; 5949 if (*p == '.' && p != input_basename) 5950 { 5951 basename_length = p - input_basename; 5952 input_suffix = p + 1; 5953 } 5954 else 5955 input_suffix = ""; 5956 5957 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then 5958 we will need to do a stat on the input_filename. The 5959 INPUT_STAT_SET signals that the stat is needed. */ 5960 input_stat_set = 0; 5961} 5962 5963/* On fatal signals, delete all the temporary files. */ 5964 5965static void 5966fatal_error (int signum) 5967{ 5968 signal (signum, SIG_DFL); 5969 delete_failure_queue (); 5970 delete_temp_files (); 5971 /* Get the same signal again, this time not handled, 5972 so its normal effect occurs. */ 5973 kill (getpid (), signum); 5974} 5975 5976extern int main (int, const char **); 5977 5978int 5979main (int argc, const char **argv) 5980{ 5981 size_t i; 5982 int value; 5983 int linker_was_run = 0; 5984 int num_linker_inputs = 0; 5985 char *explicit_link_files; 5986 char *specs_file; 5987 const char *p; 5988 struct user_specs *uptr; 5989 5990 p = argv[0] + strlen (argv[0]); 5991 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) 5992 --p; 5993 programname = p; 5994 5995 xmalloc_set_program_name (programname); 5996 5997#ifdef GCC_DRIVER_HOST_INITIALIZATION 5998 /* Perform host dependent initialization when needed. */ 5999 GCC_DRIVER_HOST_INITIALIZATION; 6000#endif 6001 6002 gcc_init_libintl (); 6003 6004 if (signal (SIGINT, SIG_IGN) != SIG_IGN) 6005 signal (SIGINT, fatal_error); 6006#ifdef SIGHUP 6007 if (signal (SIGHUP, SIG_IGN) != SIG_IGN) 6008 signal (SIGHUP, fatal_error); 6009#endif 6010 if (signal (SIGTERM, SIG_IGN) != SIG_IGN) 6011 signal (SIGTERM, fatal_error); 6012#ifdef SIGPIPE 6013 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) 6014 signal (SIGPIPE, fatal_error); 6015#endif 6016#ifdef SIGCHLD 6017 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will 6018 receive the signal. A different setting is inheritable */ 6019 signal (SIGCHLD, SIG_DFL); 6020#endif 6021 6022 /* Allocate the argument vector. */ 6023 alloc_args (); 6024 6025 obstack_init (&obstack); 6026 6027 /* Build multilib_select, et. al from the separate lines that make up each 6028 multilib selection. */ 6029 { 6030 const char *const *q = multilib_raw; 6031 int need_space; 6032 6033 obstack_init (&multilib_obstack); 6034 while ((p = *q++) != (char *) 0) 6035 obstack_grow (&multilib_obstack, p, strlen (p)); 6036 6037 obstack_1grow (&multilib_obstack, 0); 6038 multilib_select = obstack_finish (&multilib_obstack); 6039 6040 q = multilib_matches_raw; 6041 while ((p = *q++) != (char *) 0) 6042 obstack_grow (&multilib_obstack, p, strlen (p)); 6043 6044 obstack_1grow (&multilib_obstack, 0); 6045 multilib_matches = obstack_finish (&multilib_obstack); 6046 6047 q = multilib_exclusions_raw; 6048 while ((p = *q++) != (char *) 0) 6049 obstack_grow (&multilib_obstack, p, strlen (p)); 6050 6051 obstack_1grow (&multilib_obstack, 0); 6052 multilib_exclusions = obstack_finish (&multilib_obstack); 6053 6054 need_space = FALSE; 6055 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++) 6056 { 6057 if (need_space) 6058 obstack_1grow (&multilib_obstack, ' '); 6059 obstack_grow (&multilib_obstack, 6060 multilib_defaults_raw[i], 6061 strlen (multilib_defaults_raw[i])); 6062 need_space = TRUE; 6063 } 6064 6065 obstack_1grow (&multilib_obstack, 0); 6066 multilib_defaults = obstack_finish (&multilib_obstack); 6067 } 6068 6069 /* Set up to remember the pathname of gcc and any options 6070 needed for collect. We use argv[0] instead of programname because 6071 we need the complete pathname. */ 6072 obstack_init (&collect_obstack); 6073 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1); 6074 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1); 6075 putenv (obstack_finish (&collect_obstack)); 6076 6077#ifdef INIT_ENVIRONMENT 6078 /* Set up any other necessary machine specific environment variables. */ 6079 putenv (INIT_ENVIRONMENT); 6080#endif 6081 6082 /* Make a table of what switches there are (switches, n_switches). 6083 Make a table of specified input files (infiles, n_infiles). 6084 Decode switches that are handled locally. */ 6085 6086 process_command (argc, argv); 6087 6088 /* Initialize the vector of specs to just the default. 6089 This means one element containing 0s, as a terminator. */ 6090 6091 compilers = xmalloc (sizeof default_compilers); 6092 memcpy (compilers, default_compilers, sizeof default_compilers); 6093 n_compilers = n_default_compilers; 6094 6095 /* Read specs from a file if there is one. */ 6096 6097#ifdef FREEBSD_NATIVE 6098 just_machine_suffix = ""; 6099#else /* FREEBSD_NATIVE */ 6100 machine_suffix = concat (spec_machine, dir_separator_str, 6101 spec_version, dir_separator_str, NULL); 6102 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL); 6103#endif /* FREEBSD_NATIVE */ 6104 6105 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0); 6106 /* Read the specs file unless it is a default one. */ 6107 if (specs_file != 0 && strcmp (specs_file, "specs")) 6108 read_specs (specs_file, TRUE); 6109 else 6110 init_spec (); 6111 6112 /* We need to check standard_exec_prefix/just_machine_suffix/specs 6113 for any override of as, ld and libraries. */ 6114 specs_file = (char *) alloca (strlen (FBSD_DATA_PREFIX) 6115 + strlen (just_machine_suffix) 6116 + sizeof ("specs")); 6117 6118 strcpy (specs_file, FBSD_DATA_PREFIX); 6119 strcat (specs_file, just_machine_suffix); 6120 strcat (specs_file, "specs"); 6121 if (access (specs_file, R_OK) == 0) 6122 read_specs (specs_file, TRUE); 6123 6124 /* Process any configure-time defaults specified for the command line 6125 options, via OPTION_DEFAULT_SPECS. */ 6126 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++) 6127 do_option_spec (option_default_specs[i].name, 6128 option_default_specs[i].spec); 6129 6130 /* Process DRIVER_SELF_SPECS, adding any new options to the end 6131 of the command line. */ 6132 6133 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++) 6134 do_self_spec (driver_self_specs[i]); 6135 6136 /* If not cross-compiling, look for executables in the standard 6137 places. */ 6138 if (*cross_compile == '0') 6139 { 6140 if (*md_exec_prefix) 6141 { 6142 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 6143 PREFIX_PRIORITY_LAST, 0, NULL, 0); 6144 } 6145 } 6146 6147 /* Process sysroot_suffix_spec. */ 6148 if (*sysroot_suffix_spec != 0 6149 && do_spec_2 (sysroot_suffix_spec) == 0) 6150 { 6151 if (argbuf_index > 1) 6152 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC."); 6153 else if (argbuf_index == 1) 6154 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]); 6155 } 6156 6157 /* Process sysroot_hdrs_suffix_spec. */ 6158 if (*sysroot_hdrs_suffix_spec != 0 6159 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0) 6160 { 6161 if (argbuf_index > 1) 6162 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC."); 6163 else if (argbuf_index == 1) 6164 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]); 6165 } 6166 6167 /* Look for startfiles in the standard places. */ 6168 if (*startfile_prefix_spec != 0 6169 && do_spec_2 (startfile_prefix_spec) == 0 6170 && do_spec_1 (" ", 0, NULL) == 0) 6171 { 6172 int ndx; 6173 for (ndx = 0; ndx < argbuf_index; ndx++) 6174 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS", 6175 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6176 } 6177 /* We should eventually get rid of all these and stick to 6178 startfile_prefix_spec exclusively. */ 6179 else if (*cross_compile == '0' || target_system_root) 6180 { 6181 if (*md_exec_prefix) 6182 add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 6183 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6184 6185 if (*md_startfile_prefix) 6186 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix, 6187 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6188 6189 if (*md_startfile_prefix_1) 6190 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1, 6191 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6192 6193 /* If standard_startfile_prefix is relative, base it on 6194 standard_exec_prefix. This lets us move the installed tree 6195 as a unit. If GCC_EXEC_PREFIX is defined, base 6196 standard_startfile_prefix on that as well. 6197 6198 If the prefix is relative, only search it for native compilers; 6199 otherwise we will search a directory containing host libraries. */ 6200 if (IS_ABSOLUTE_PATH (standard_startfile_prefix)) 6201 add_sysrooted_prefix (&startfile_prefixes, 6202 standard_startfile_prefix, "BINUTILS", 6203 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6204 else if (*cross_compile == '0') 6205 { 6206 if (gcc_exec_prefix) 6207 add_prefix (&startfile_prefixes, 6208 concat (gcc_exec_prefix, machine_suffix, 6209 standard_startfile_prefix, NULL), 6210 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6211 add_prefix (&startfile_prefixes, 6212 concat (standard_exec_prefix, 6213 machine_suffix, 6214 standard_startfile_prefix, NULL), 6215 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6216 } 6217 6218#ifndef FREEBSD_NATIVE 6219 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_1, 6220 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6221 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_2, 6222 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6223#endif /* not FREEBSD_NATIVE */ 6224#if 0 /* Can cause surprises, and one can use -B./ instead. */ 6225 add_prefix (&startfile_prefixes, "./", NULL, 6226 PREFIX_PRIORITY_LAST, 1, NULL, 0); 6227#endif 6228 } 6229 6230 /* Process any user specified specs in the order given on the command 6231 line. */ 6232 for (uptr = user_specs_head; uptr; uptr = uptr->next) 6233 { 6234 char *filename = find_a_file (&startfile_prefixes, uptr->filename, 6235 R_OK, 0); 6236 read_specs (filename ? filename : uptr->filename, FALSE); 6237 } 6238 6239 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */ 6240 if (gcc_exec_prefix) 6241 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 6242 spec_version, dir_separator_str, NULL); 6243 6244 /* Now we have the specs. 6245 Set the `valid' bits for switches that match anything in any spec. */ 6246 6247 validate_all_switches (); 6248 6249 /* Now that we have the switches and the specs, set 6250 the subdirectory based on the options. */ 6251 set_multilib_dir (); 6252 6253 /* Warn about any switches that no pass was interested in. */ 6254 6255 for (i = 0; (int) i < n_switches; i++) 6256 if (! switches[i].validated) 6257 error ("unrecognized option `-%s'", switches[i].part1); 6258 6259 /* Obey some of the options. */ 6260 6261 if (print_search_dirs) 6262 { 6263 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix); 6264 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0)); 6265 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0)); 6266 return (0); 6267 } 6268 6269 if (print_file_name) 6270 { 6271 printf ("%s\n", find_file (print_file_name)); 6272 return (0); 6273 } 6274 6275 if (print_prog_name) 6276 { 6277 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0); 6278 printf ("%s\n", (newname ? newname : print_prog_name)); 6279 return (0); 6280 } 6281 6282 if (print_multi_lib) 6283 { 6284 print_multilib_info (); 6285 return (0); 6286 } 6287 6288 if (print_multi_directory) 6289 { 6290 if (multilib_dir == NULL) 6291 printf (".\n"); 6292 else 6293 printf ("%s\n", multilib_dir); 6294 return (0); 6295 } 6296 6297 if (print_multi_os_directory) 6298 { 6299 if (multilib_os_dir == NULL) 6300 printf (".\n"); 6301 else 6302 printf ("%s\n", multilib_os_dir); 6303 return (0); 6304 } 6305 6306 if (target_help_flag) 6307 { 6308 /* Print if any target specific options. */ 6309 6310 /* We do not exit here. Instead we have created a fake input file 6311 called 'target-dummy' which needs to be compiled, and we pass this 6312 on to the various sub-processes, along with the --target-help 6313 switch. */ 6314 } 6315 6316 if (print_help_list) 6317 { 6318 display_help (); 6319 6320 if (! verbose_flag) 6321 { 6322 printf (_("\nFor bug reporting instructions, please see:\n")); 6323 printf ("%s.\n", bug_report_url); 6324 6325 return (0); 6326 } 6327 6328 /* We do not exit here. Instead we have created a fake input file 6329 called 'help-dummy' which needs to be compiled, and we pass this 6330 on the various sub-processes, along with the --help switch. */ 6331 } 6332 6333 if (verbose_flag) 6334 { 6335 int n; 6336 const char *thrmod; 6337 6338 notice ("Configured with: %s\n", configuration_arguments); 6339 6340#ifdef THREAD_MODEL_SPEC 6341 /* We could have defined THREAD_MODEL_SPEC to "%*" by default, 6342 but there's no point in doing all this processing just to get 6343 thread_model back. */ 6344 obstack_init (&obstack); 6345 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model); 6346 obstack_1grow (&obstack, '\0'); 6347 thrmod = obstack_finish (&obstack); 6348#else 6349 thrmod = thread_model; 6350#endif 6351 6352 notice ("Thread model: %s\n", thrmod); 6353 6354 /* compiler_version is truncated at the first space when initialized 6355 from version string, so truncate version_string at the first space 6356 before comparing. */ 6357 for (n = 0; version_string[n]; n++) 6358 if (version_string[n] == ' ') 6359 break; 6360 6361 if (! strncmp (version_string, compiler_version, n) 6362 && compiler_version[n] == 0) 6363 notice ("gcc version %s\n", version_string); 6364 else 6365 notice ("gcc driver version %s executing gcc version %s\n", 6366 version_string, compiler_version); 6367 6368 if (n_infiles == 0) 6369 return (0); 6370 } 6371 6372 if (n_infiles == added_libraries) 6373 fatal ("No input files specified"); 6374 6375 /* Make a place to record the compiler output file names 6376 that correspond to the input files. */ 6377 6378 i = n_infiles; 6379 i += lang_specific_extra_outfiles; 6380 outfiles = xcalloc (i, sizeof (char *)); 6381 6382 /* Record which files were specified explicitly as link input. */ 6383 6384 explicit_link_files = xcalloc (1, n_infiles); 6385 6386 if (combine_inputs) 6387 { 6388 int lang_n_infiles = 0; 6389 for (i = 0; (int) i < n_infiles; i++) 6390 { 6391 const char *name = infiles[i].name; 6392 struct compiler *compiler 6393 = lookup_compiler (name, strlen (name), infiles[i].language); 6394 if (compiler == NULL) 6395 error ("%s: linker input file unused because linking not done", 6396 name); 6397 else if (lang_n_infiles > 0 && compiler != input_file_compiler) 6398 fatal ("cannot specify -o with -c or -S and multiple languages"); 6399 else 6400 { 6401 lang_n_infiles++; 6402 input_file_compiler = compiler; 6403 } 6404 } 6405 } 6406 6407 for (i = 0; (int) i < (combine_inputs ? 1 : n_infiles); i++) 6408 { 6409 int this_file_error = 0; 6410 6411 /* Tell do_spec what to substitute for %i. */ 6412 6413 input_file_number = i; 6414 set_input (infiles[i].name); 6415 6416 /* Use the same thing in %o, unless cp->spec says otherwise. */ 6417 6418 outfiles[i] = input_filename; 6419 6420 /* Figure out which compiler from the file's suffix. */ 6421 6422 if (! combine_inputs) 6423 input_file_compiler 6424 = lookup_compiler (infiles[i].name, input_filename_length, 6425 infiles[i].language); 6426 6427 if (input_file_compiler) 6428 { 6429 /* Ok, we found an applicable compiler. Run its spec. */ 6430 6431 if (input_file_compiler->spec[0] == '#') 6432 { 6433 error ("%s: %s compiler not installed on this system", 6434 input_filename, &input_file_compiler->spec[1]); 6435 this_file_error = 1; 6436 } 6437 else 6438 { 6439 value = do_spec (input_file_compiler->spec); 6440 if (value < 0) 6441 this_file_error = 1; 6442 } 6443 } 6444 6445 /* If this file's name does not contain a recognized suffix, 6446 record it as explicit linker input. */ 6447 6448 else 6449 explicit_link_files[i] = 1; 6450 6451 /* Clear the delete-on-failure queue, deleting the files in it 6452 if this compilation failed. */ 6453 6454 if (this_file_error) 6455 { 6456 delete_failure_queue (); 6457 error_count++; 6458 } 6459 /* If this compilation succeeded, don't delete those files later. */ 6460 clear_failure_queue (); 6461 } 6462 6463 /* Reset the output file name to the first input file name, for use 6464 with %b in LINK_SPEC on a target that prefers not to emit a.out 6465 by default. */ 6466 if (n_infiles > 0) 6467 set_input (infiles[0].name); 6468 6469 if (error_count == 0) 6470 { 6471 /* Make sure INPUT_FILE_NUMBER points to first available open 6472 slot. */ 6473 input_file_number = n_infiles; 6474 if (lang_specific_pre_link ()) 6475 error_count++; 6476 } 6477 6478 /* Determine if there are any linker input files. */ 6479 num_linker_inputs = 0; 6480 for (i = 0; (int) i < n_infiles; i++) 6481 if (explicit_link_files[i] || outfiles[i] != NULL) 6482 num_linker_inputs++; 6483 6484 /* Run ld to link all the compiler output files. */ 6485 6486 if (num_linker_inputs > 0 && error_count == 0) 6487 { 6488 int tmp = execution_count; 6489 6490 /* We'll use ld if we can't find collect2. */ 6491 if (! strcmp (linker_name_spec, "collect2")) 6492 { 6493 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0); 6494 if (s == NULL) 6495 linker_name_spec = "ld"; 6496 } 6497 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 6498 for collect. */ 6499 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH"); 6500 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV); 6501 6502 value = do_spec (link_command_spec); 6503 if (value < 0) 6504 error_count = 1; 6505 linker_was_run = (tmp != execution_count); 6506 } 6507 6508 /* If options said don't run linker, 6509 complain about input files to be given to the linker. */ 6510 6511 if (! linker_was_run && error_count == 0) 6512 for (i = 0; (int) i < n_infiles; i++) 6513 if (explicit_link_files[i]) 6514 error ("%s: linker input file unused because linking not done", 6515 outfiles[i]); 6516 6517 /* Delete some or all of the temporary files we made. */ 6518 6519 if (error_count) 6520 delete_failure_queue (); 6521 delete_temp_files (); 6522 6523 if (print_help_list) 6524 { 6525 printf (("\nFor bug reporting instructions, please see:\n")); 6526 printf ("%s\n", bug_report_url); 6527 } 6528 6529 return (signal_count != 0 ? 2 6530 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1) 6531 : 0); 6532} 6533 6534/* Find the proper compilation spec for the file name NAME, 6535 whose length is LENGTH. LANGUAGE is the specified language, 6536 or 0 if this file is to be passed to the linker. */ 6537 6538static struct compiler * 6539lookup_compiler (const char *name, size_t length, const char *language) 6540{ 6541 struct compiler *cp; 6542 6543 /* If this was specified by the user to be a linker input, indicate that. */ 6544 if (language != 0 && language[0] == '*') 6545 return 0; 6546 6547 /* Otherwise, look for the language, if one is spec'd. */ 6548 if (language != 0) 6549 { 6550 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6551 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language)) 6552 return cp; 6553 6554 error ("language %s not recognized", language); 6555 return 0; 6556 } 6557 6558 /* Look for a suffix. */ 6559 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6560 { 6561 if (/* The suffix `-' matches only the file name `-'. */ 6562 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6563 || (strlen (cp->suffix) < length 6564 /* See if the suffix matches the end of NAME. */ 6565 && !strcmp (cp->suffix, 6566 name + length - strlen (cp->suffix)) 6567 )) 6568 break; 6569 } 6570 6571#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM) 6572 /* look again, but case-insensitively this time. */ 6573 if (cp < compilers) 6574 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6575 { 6576 if (/* The suffix `-' matches only the file name `-'. */ 6577 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6578 || (strlen (cp->suffix) < length 6579 /* See if the suffix matches the end of NAME. */ 6580 && ((!strcmp (cp->suffix, 6581 name + length - strlen (cp->suffix)) 6582 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) 6583 && !strcasecmp (cp->suffix, 6584 name + length - strlen (cp->suffix))) 6585 )) 6586 break; 6587 } 6588#endif 6589 6590 if (cp >= compilers) 6591 { 6592 if (cp->spec[0] != '@') 6593 /* A non-alias entry: return it. */ 6594 return cp; 6595 6596 /* An alias entry maps a suffix to a language. 6597 Search for the language; pass 0 for NAME and LENGTH 6598 to avoid infinite recursion if language not found. */ 6599 return lookup_compiler (NULL, 0, cp->spec + 1); 6600 } 6601 return 0; 6602} 6603 6604static char * 6605save_string (const char *s, int len) 6606{ 6607 char *result = xmalloc (len + 1); 6608 6609 memcpy (result, s, len); 6610 result[len] = 0; 6611 return result; 6612} 6613 6614void 6615pfatal_with_name (const char *name) 6616{ 6617 perror_with_name (name); 6618 delete_temp_files (); 6619 exit (1); 6620} 6621 6622static void 6623perror_with_name (const char *name) 6624{ 6625 error ("%s: %s", name, xstrerror (errno)); 6626} 6627 6628static void 6629pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg) 6630{ 6631 if (errmsg_arg) 6632 { 6633 int save_errno = errno; 6634 6635 /* Space for trailing '\0' is in %s. */ 6636 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg)); 6637 sprintf (msg, errmsg_fmt, errmsg_arg); 6638 errmsg_fmt = msg; 6639 6640 errno = save_errno; 6641 } 6642 6643 pfatal_with_name (errmsg_fmt); 6644} 6645 6646/* Output an error message and exit. */ 6647 6648void 6649fancy_abort (void) 6650{ 6651 fatal ("internal gcc abort"); 6652} 6653 6654/* Output an error message and exit. */ 6655 6656void 6657fatal (const char *msgid, ...) 6658{ 6659 va_list ap; 6660 6661 va_start (ap, msgid); 6662 6663 fprintf (stderr, "%s: ", programname); 6664 vfprintf (stderr, _(msgid), ap); 6665 va_end (ap); 6666 fprintf (stderr, "\n"); 6667 delete_temp_files (); 6668 exit (1); 6669} 6670 6671void 6672error (const char *msgid, ...) 6673{ 6674 va_list ap; 6675 6676 va_start (ap, msgid); 6677 fprintf (stderr, "%s: ", programname); 6678 vfprintf (stderr, _(msgid), ap); 6679 va_end (ap); 6680 6681 fprintf (stderr, "\n"); 6682} 6683 6684static void 6685notice (const char *msgid, ...) 6686{ 6687 va_list ap; 6688 6689 va_start (ap, msgid); 6690 vfprintf (stderr, _(msgid), ap); 6691 va_end (ap); 6692} 6693 6694static inline void 6695validate_switches_from_spec (const char *spec) 6696{ 6697 const char *p = spec; 6698 char c; 6699 while ((c = *p++)) 6700 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{'))) 6701 /* We have a switch spec. */ 6702 p = validate_switches (p + 1); 6703} 6704 6705static void 6706validate_all_switches (void) 6707{ 6708 struct compiler *comp; 6709 struct spec_list *spec; 6710 6711 for (comp = compilers; comp->spec; comp++) 6712 validate_switches_from_spec (comp->spec); 6713 6714 /* Look through the linked list of specs read from the specs file. */ 6715 for (spec = specs; spec; spec = spec->next) 6716 validate_switches_from_spec (*spec->ptr_spec); 6717 6718 validate_switches_from_spec (link_command_spec); 6719} 6720 6721/* Look at the switch-name that comes after START 6722 and mark as valid all supplied switches that match it. */ 6723 6724static const char * 6725validate_switches (const char *start) 6726{ 6727 const char *p = start; 6728 const char *atom; 6729 size_t len; 6730 int i; 6731 bool suffix = false; 6732 bool starred = false; 6733 6734#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 6735 6736next_member: 6737 SKIP_WHITE (); 6738 6739 if (*p == '!') 6740 p++; 6741 6742 SKIP_WHITE (); 6743 if (*p == '.') 6744 suffix = true, p++; 6745 6746 atom = p; 6747 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '=' 6748 || *p == ',' || *p == '.' || *p == '@') 6749 p++; 6750 len = p - atom; 6751 6752 if (*p == '*') 6753 starred = true, p++; 6754 6755 SKIP_WHITE (); 6756 6757 if (!suffix) 6758 { 6759 /* Mark all matching switches as valid. */ 6760 for (i = 0; i < n_switches; i++) 6761 if (!strncmp (switches[i].part1, atom, len) 6762 && (starred || switches[i].part1[len] == 0)) 6763 switches[i].validated = 1; 6764 } 6765 6766 if (*p) p++; 6767 if (*p && (p[-1] == '|' || p[-1] == '&')) 6768 goto next_member; 6769 6770 if (*p && p[-1] == ':') 6771 { 6772 while (*p && *p != ';' && *p != '}') 6773 { 6774 if (*p == '%') 6775 { 6776 p++; 6777 if (*p == '{' || *p == '<') 6778 p = validate_switches (p+1); 6779 else if (p[0] == 'W' && p[1] == '{') 6780 p = validate_switches (p+2); 6781 } 6782 else 6783 p++; 6784 } 6785 6786 if (*p) p++; 6787 if (*p && p[-1] == ';') 6788 goto next_member; 6789 } 6790 6791 return p; 6792#undef SKIP_WHITE 6793} 6794 6795struct mdswitchstr 6796{ 6797 const char *str; 6798 int len; 6799}; 6800 6801static struct mdswitchstr *mdswitches; 6802static int n_mdswitches; 6803 6804/* Check whether a particular argument was used. The first time we 6805 canonicalize the switches to keep only the ones we care about. */ 6806 6807static int 6808used_arg (const char *p, int len) 6809{ 6810 struct mswitchstr 6811 { 6812 const char *str; 6813 const char *replace; 6814 int len; 6815 int rep_len; 6816 }; 6817 6818 static struct mswitchstr *mswitches; 6819 static int n_mswitches; 6820 int i, j; 6821 6822 if (!mswitches) 6823 { 6824 struct mswitchstr *matches; 6825 const char *q; 6826 int cnt = 0; 6827 6828 /* Break multilib_matches into the component strings of string 6829 and replacement string. */ 6830 for (q = multilib_matches; *q != '\0'; q++) 6831 if (*q == ';') 6832 cnt++; 6833 6834 matches = alloca ((sizeof (struct mswitchstr)) * cnt); 6835 i = 0; 6836 q = multilib_matches; 6837 while (*q != '\0') 6838 { 6839 matches[i].str = q; 6840 while (*q != ' ') 6841 { 6842 if (*q == '\0') 6843 abort (); 6844 q++; 6845 } 6846 matches[i].len = q - matches[i].str; 6847 6848 matches[i].replace = ++q; 6849 while (*q != ';' && *q != '\0') 6850 { 6851 if (*q == ' ') 6852 abort (); 6853 q++; 6854 } 6855 matches[i].rep_len = q - matches[i].replace; 6856 i++; 6857 if (*q == ';') 6858 q++; 6859 } 6860 6861 /* Now build a list of the replacement string for switches that we care 6862 about. Make sure we allocate at least one entry. This prevents 6863 xmalloc from calling fatal, and prevents us from re-executing this 6864 block of code. */ 6865 mswitches 6866 = xmalloc (sizeof (struct mswitchstr) 6867 * (n_mdswitches + (n_switches ? n_switches : 1))); 6868 for (i = 0; i < n_switches; i++) 6869 { 6870 int xlen = strlen (switches[i].part1); 6871 for (j = 0; j < cnt; j++) 6872 if (xlen == matches[j].len 6873 && ! strncmp (switches[i].part1, matches[j].str, xlen)) 6874 { 6875 mswitches[n_mswitches].str = matches[j].replace; 6876 mswitches[n_mswitches].len = matches[j].rep_len; 6877 mswitches[n_mswitches].replace = (char *) 0; 6878 mswitches[n_mswitches].rep_len = 0; 6879 n_mswitches++; 6880 break; 6881 } 6882 } 6883 6884 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present 6885 on the command line nor any options mutually incompatible with 6886 them. */ 6887 for (i = 0; i < n_mdswitches; i++) 6888 { 6889 const char *r; 6890 6891 for (q = multilib_options; *q != '\0'; q++) 6892 { 6893 while (*q == ' ') 6894 q++; 6895 6896 r = q; 6897 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0 6898 || strchr (" /", q[mdswitches[i].len]) == NULL) 6899 { 6900 while (*q != ' ' && *q != '/' && *q != '\0') 6901 q++; 6902 if (*q != '/') 6903 break; 6904 q++; 6905 } 6906 6907 if (*q != ' ' && *q != '\0') 6908 { 6909 while (*r != ' ' && *r != '\0') 6910 { 6911 q = r; 6912 while (*q != ' ' && *q != '/' && *q != '\0') 6913 q++; 6914 6915 if (used_arg (r, q - r)) 6916 break; 6917 6918 if (*q != '/') 6919 { 6920 mswitches[n_mswitches].str = mdswitches[i].str; 6921 mswitches[n_mswitches].len = mdswitches[i].len; 6922 mswitches[n_mswitches].replace = (char *) 0; 6923 mswitches[n_mswitches].rep_len = 0; 6924 n_mswitches++; 6925 break; 6926 } 6927 6928 r = q + 1; 6929 } 6930 break; 6931 } 6932 } 6933 } 6934 } 6935 6936 for (i = 0; i < n_mswitches; i++) 6937 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len)) 6938 return 1; 6939 6940 return 0; 6941} 6942 6943static int 6944default_arg (const char *p, int len) 6945{ 6946 int i; 6947 6948 for (i = 0; i < n_mdswitches; i++) 6949 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len)) 6950 return 1; 6951 6952 return 0; 6953} 6954 6955/* Work out the subdirectory to use based on the options. The format of 6956 multilib_select is a list of elements. Each element is a subdirectory 6957 name followed by a list of options followed by a semicolon. The format 6958 of multilib_exclusions is the same, but without the preceding 6959 directory. First gcc will check the exclusions, if none of the options 6960 beginning with an exclamation point are present, and all of the other 6961 options are present, then we will ignore this completely. Passing 6962 that, gcc will consider each multilib_select in turn using the same 6963 rules for matching the options. If a match is found, that subdirectory 6964 will be used. */ 6965 6966static void 6967set_multilib_dir (void) 6968{ 6969 const char *p; 6970 unsigned int this_path_len; 6971 const char *this_path, *this_arg; 6972 const char *start, *end; 6973 int not_arg; 6974 int ok, ndfltok, first; 6975 6976 n_mdswitches = 0; 6977 start = multilib_defaults; 6978 while (*start == ' ' || *start == '\t') 6979 start++; 6980 while (*start != '\0') 6981 { 6982 n_mdswitches++; 6983 while (*start != ' ' && *start != '\t' && *start != '\0') 6984 start++; 6985 while (*start == ' ' || *start == '\t') 6986 start++; 6987 } 6988 6989 if (n_mdswitches) 6990 { 6991 int i = 0; 6992 6993 mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches); 6994 for (start = multilib_defaults; *start != '\0'; start = end + 1) 6995 { 6996 while (*start == ' ' || *start == '\t') 6997 start++; 6998 6999 if (*start == '\0') 7000 break; 7001 7002 for (end = start + 1; 7003 *end != ' ' && *end != '\t' && *end != '\0'; end++) 7004 ; 7005 7006 obstack_grow (&multilib_obstack, start, end - start); 7007 obstack_1grow (&multilib_obstack, 0); 7008 mdswitches[i].str = obstack_finish (&multilib_obstack); 7009 mdswitches[i++].len = end - start; 7010 7011 if (*end == '\0') 7012 break; 7013 } 7014 } 7015 7016 p = multilib_exclusions; 7017 while (*p != '\0') 7018 { 7019 /* Ignore newlines. */ 7020 if (*p == '\n') 7021 { 7022 ++p; 7023 continue; 7024 } 7025 7026 /* Check the arguments. */ 7027 ok = 1; 7028 while (*p != ';') 7029 { 7030 if (*p == '\0') 7031 abort (); 7032 7033 if (! ok) 7034 { 7035 ++p; 7036 continue; 7037 } 7038 7039 this_arg = p; 7040 while (*p != ' ' && *p != ';') 7041 { 7042 if (*p == '\0') 7043 abort (); 7044 ++p; 7045 } 7046 7047 if (*this_arg != '!') 7048 not_arg = 0; 7049 else 7050 { 7051 not_arg = 1; 7052 ++this_arg; 7053 } 7054 7055 ok = used_arg (this_arg, p - this_arg); 7056 if (not_arg) 7057 ok = ! ok; 7058 7059 if (*p == ' ') 7060 ++p; 7061 } 7062 7063 if (ok) 7064 return; 7065 7066 ++p; 7067 } 7068 7069 first = 1; 7070 p = multilib_select; 7071 while (*p != '\0') 7072 { 7073 /* Ignore newlines. */ 7074 if (*p == '\n') 7075 { 7076 ++p; 7077 continue; 7078 } 7079 7080 /* Get the initial path. */ 7081 this_path = p; 7082 while (*p != ' ') 7083 { 7084 if (*p == '\0') 7085 abort (); 7086 ++p; 7087 } 7088 this_path_len = p - this_path; 7089 7090 /* Check the arguments. */ 7091 ok = 1; 7092 ndfltok = 1; 7093 ++p; 7094 while (*p != ';') 7095 { 7096 if (*p == '\0') 7097 abort (); 7098 7099 if (! ok) 7100 { 7101 ++p; 7102 continue; 7103 } 7104 7105 this_arg = p; 7106 while (*p != ' ' && *p != ';') 7107 { 7108 if (*p == '\0') 7109 abort (); 7110 ++p; 7111 } 7112 7113 if (*this_arg != '!') 7114 not_arg = 0; 7115 else 7116 { 7117 not_arg = 1; 7118 ++this_arg; 7119 } 7120 7121 /* If this is a default argument, we can just ignore it. 7122 This is true even if this_arg begins with '!'. Beginning 7123 with '!' does not mean that this argument is necessarily 7124 inappropriate for this library: it merely means that 7125 there is a more specific library which uses this 7126 argument. If this argument is a default, we need not 7127 consider that more specific library. */ 7128 ok = used_arg (this_arg, p - this_arg); 7129 if (not_arg) 7130 ok = ! ok; 7131 7132 if (! ok) 7133 ndfltok = 0; 7134 7135 if (default_arg (this_arg, p - this_arg)) 7136 ok = 1; 7137 7138 if (*p == ' ') 7139 ++p; 7140 } 7141 7142 if (ok && first) 7143 { 7144 if (this_path_len != 1 7145 || this_path[0] != '.') 7146 { 7147 char *new_multilib_dir = xmalloc (this_path_len + 1); 7148 char *q; 7149 7150 strncpy (new_multilib_dir, this_path, this_path_len); 7151 new_multilib_dir[this_path_len] = '\0'; 7152 q = strchr (new_multilib_dir, ':'); 7153 if (q != NULL) 7154 *q = '\0'; 7155 multilib_dir = new_multilib_dir; 7156 } 7157 first = 0; 7158 } 7159 7160 if (ndfltok) 7161 { 7162 const char *q = this_path, *end = this_path + this_path_len; 7163 7164 while (q < end && *q != ':') 7165 q++; 7166 if (q < end) 7167 { 7168 char *new_multilib_os_dir = xmalloc (end - q); 7169 memcpy (new_multilib_os_dir, q + 1, end - q - 1); 7170 new_multilib_os_dir[end - q - 1] = '\0'; 7171 multilib_os_dir = new_multilib_os_dir; 7172 break; 7173 } 7174 } 7175 7176 ++p; 7177 } 7178 7179 if (multilib_dir == NULL && multilib_os_dir != NULL 7180 && strcmp (multilib_os_dir, ".") == 0) 7181 { 7182 free ((char *) multilib_os_dir); 7183 multilib_os_dir = NULL; 7184 } 7185 else if (multilib_dir != NULL && multilib_os_dir == NULL) 7186 multilib_os_dir = multilib_dir; 7187} 7188 7189/* Print out the multiple library subdirectory selection 7190 information. This prints out a series of lines. Each line looks 7191 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is 7192 required. Only the desired options are printed out, the negative 7193 matches. The options are print without a leading dash. There are 7194 no spaces to make it easy to use the information in the shell. 7195 Each subdirectory is printed only once. This assumes the ordering 7196 generated by the genmultilib script. Also, we leave out ones that match 7197 the exclusions. */ 7198 7199static void 7200print_multilib_info (void) 7201{ 7202 const char *p = multilib_select; 7203 const char *last_path = 0, *this_path; 7204 int skip; 7205 unsigned int last_path_len = 0; 7206 7207 while (*p != '\0') 7208 { 7209 skip = 0; 7210 /* Ignore newlines. */ 7211 if (*p == '\n') 7212 { 7213 ++p; 7214 continue; 7215 } 7216 7217 /* Get the initial path. */ 7218 this_path = p; 7219 while (*p != ' ') 7220 { 7221 if (*p == '\0') 7222 abort (); 7223 ++p; 7224 } 7225 7226 /* When --disable-multilib was used but target defines 7227 MULTILIB_OSDIRNAMES, entries starting with .: are there just 7228 to find multilib_os_dir, so skip them from output. */ 7229 if (this_path[0] == '.' && this_path[1] == ':') 7230 skip = 1; 7231 7232 /* Check for matches with the multilib_exclusions. We don't bother 7233 with the '!' in either list. If any of the exclusion rules match 7234 all of its options with the select rule, we skip it. */ 7235 { 7236 const char *e = multilib_exclusions; 7237 const char *this_arg; 7238 7239 while (*e != '\0') 7240 { 7241 int m = 1; 7242 /* Ignore newlines. */ 7243 if (*e == '\n') 7244 { 7245 ++e; 7246 continue; 7247 } 7248 7249 /* Check the arguments. */ 7250 while (*e != ';') 7251 { 7252 const char *q; 7253 int mp = 0; 7254 7255 if (*e == '\0') 7256 abort (); 7257 7258 if (! m) 7259 { 7260 ++e; 7261 continue; 7262 } 7263 7264 this_arg = e; 7265 7266 while (*e != ' ' && *e != ';') 7267 { 7268 if (*e == '\0') 7269 abort (); 7270 ++e; 7271 } 7272 7273 q = p + 1; 7274 while (*q != ';') 7275 { 7276 const char *arg; 7277 int len = e - this_arg; 7278 7279 if (*q == '\0') 7280 abort (); 7281 7282 arg = q; 7283 7284 while (*q != ' ' && *q != ';') 7285 { 7286 if (*q == '\0') 7287 abort (); 7288 ++q; 7289 } 7290 7291 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) || 7292 default_arg (this_arg, e - this_arg)) 7293 { 7294 mp = 1; 7295 break; 7296 } 7297 7298 if (*q == ' ') 7299 ++q; 7300 } 7301 7302 if (! mp) 7303 m = 0; 7304 7305 if (*e == ' ') 7306 ++e; 7307 } 7308 7309 if (m) 7310 { 7311 skip = 1; 7312 break; 7313 } 7314 7315 if (*e != '\0') 7316 ++e; 7317 } 7318 } 7319 7320 if (! skip) 7321 { 7322 /* If this is a duplicate, skip it. */ 7323 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len 7324 && ! strncmp (last_path, this_path, last_path_len)); 7325 7326 last_path = this_path; 7327 last_path_len = p - this_path; 7328 } 7329 7330 /* If this directory requires any default arguments, we can skip 7331 it. We will already have printed a directory identical to 7332 this one which does not require that default argument. */ 7333 if (! skip) 7334 { 7335 const char *q; 7336 7337 q = p + 1; 7338 while (*q != ';') 7339 { 7340 const char *arg; 7341 7342 if (*q == '\0') 7343 abort (); 7344 7345 if (*q == '!') 7346 arg = NULL; 7347 else 7348 arg = q; 7349 7350 while (*q != ' ' && *q != ';') 7351 { 7352 if (*q == '\0') 7353 abort (); 7354 ++q; 7355 } 7356 7357 if (arg != NULL 7358 && default_arg (arg, q - arg)) 7359 { 7360 skip = 1; 7361 break; 7362 } 7363 7364 if (*q == ' ') 7365 ++q; 7366 } 7367 } 7368 7369 if (! skip) 7370 { 7371 const char *p1; 7372 7373 for (p1 = last_path; p1 < p && *p1 != ':'; p1++) 7374 putchar (*p1); 7375 putchar (';'); 7376 } 7377 7378 ++p; 7379 while (*p != ';') 7380 { 7381 int use_arg; 7382 7383 if (*p == '\0') 7384 abort (); 7385 7386 if (skip) 7387 { 7388 ++p; 7389 continue; 7390 } 7391 7392 use_arg = *p != '!'; 7393 7394 if (use_arg) 7395 putchar ('@'); 7396 7397 while (*p != ' ' && *p != ';') 7398 { 7399 if (*p == '\0') 7400 abort (); 7401 if (use_arg) 7402 putchar (*p); 7403 ++p; 7404 } 7405 7406 if (*p == ' ') 7407 ++p; 7408 } 7409 7410 if (! skip) 7411 { 7412 /* If there are extra options, print them now. */ 7413 if (multilib_extra && *multilib_extra) 7414 { 7415 int print_at = TRUE; 7416 const char *q; 7417 7418 for (q = multilib_extra; *q != '\0'; q++) 7419 { 7420 if (*q == ' ') 7421 print_at = TRUE; 7422 else 7423 { 7424 if (print_at) 7425 putchar ('@'); 7426 putchar (*q); 7427 print_at = FALSE; 7428 } 7429 } 7430 } 7431 7432 putchar ('\n'); 7433 } 7434 7435 ++p; 7436 } 7437} 7438 7439/* if-exists built-in spec function. 7440 7441 Checks to see if the file specified by the absolute pathname in 7442 ARGS exists. Returns that pathname if found. 7443 7444 The usual use for this function is to check for a library file 7445 (whose name has been expanded with %s). */ 7446 7447static const char * 7448if_exists_spec_function (int argc, const char **argv) 7449{ 7450 /* Must have only one argument. */ 7451 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7452 return argv[0]; 7453 7454 return NULL; 7455} 7456 7457/* if-exists-else built-in spec function. 7458 7459 This is like if-exists, but takes an additional argument which 7460 is returned if the first argument does not exist. */ 7461 7462static const char * 7463if_exists_else_spec_function (int argc, const char **argv) 7464{ 7465 /* Must have exactly two arguments. */ 7466 if (argc != 2) 7467 return NULL; 7468 7469 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7470 return argv[0]; 7471 7472 return argv[1]; 7473}
| 3412 _("(C)")); 3413 fputs (_("This is free software; see the source for copying conditions. There is NO\n\ 3414warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"), 3415 stdout); 3416 exit (0); 3417 } 3418 else if (strcmp (argv[i], "-fhelp") == 0) 3419 { 3420 /* translate_options () has turned --help into -fhelp. */ 3421 print_help_list = 1; 3422 3423 /* We will be passing a dummy file on to the sub-processes. */ 3424 n_infiles++; 3425 n_switches++; 3426 3427 /* CPP driver cannot obtain switch from cc1_options. */ 3428 if (is_cpp_driver) 3429 add_preprocessor_option ("--help", 6); 3430 add_assembler_option ("--help", 6); 3431 add_linker_option ("--help", 6); 3432 } 3433 else if (strcmp (argv[i], "-ftarget-help") == 0) 3434 { 3435 /* translate_options() has turned --target-help into -ftarget-help. */ 3436 target_help_flag = 1; 3437 3438 /* We will be passing a dummy file on to the sub-processes. */ 3439 n_infiles++; 3440 n_switches++; 3441 3442 /* CPP driver cannot obtain switch from cc1_options. */ 3443 if (is_cpp_driver) 3444 add_preprocessor_option ("--target-help", 13); 3445 add_assembler_option ("--target-help", 13); 3446 add_linker_option ("--target-help", 13); 3447 } 3448 else if (! strcmp (argv[i], "-pass-exit-codes")) 3449 { 3450 pass_exit_codes = 1; 3451 n_switches++; 3452 } 3453 else if (! strcmp (argv[i], "-print-search-dirs")) 3454 print_search_dirs = 1; 3455 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3456 print_file_name = "libgcc.a"; 3457 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3458 print_file_name = argv[i] + 17; 3459 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3460 print_prog_name = argv[i] + 17; 3461 else if (! strcmp (argv[i], "-print-multi-lib")) 3462 print_multi_lib = 1; 3463 else if (! strcmp (argv[i], "-print-multi-directory")) 3464 print_multi_directory = 1; 3465 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3466 print_multi_os_directory = 1; 3467 else if (! strncmp (argv[i], "-Wa,", 4)) 3468 { 3469 int prev, j; 3470 /* Pass the rest of this option to the assembler. */ 3471 3472 /* Split the argument at commas. */ 3473 prev = 4; 3474 for (j = 4; argv[i][j]; j++) 3475 if (argv[i][j] == ',') 3476 { 3477 add_assembler_option (argv[i] + prev, j - prev); 3478 prev = j + 1; 3479 } 3480 3481 /* Record the part after the last comma. */ 3482 add_assembler_option (argv[i] + prev, j - prev); 3483 } 3484 else if (! strncmp (argv[i], "-Wp,", 4)) 3485 { 3486 int prev, j; 3487 /* Pass the rest of this option to the preprocessor. */ 3488 3489 /* Split the argument at commas. */ 3490 prev = 4; 3491 for (j = 4; argv[i][j]; j++) 3492 if (argv[i][j] == ',') 3493 { 3494 add_preprocessor_option (argv[i] + prev, j - prev); 3495 prev = j + 1; 3496 } 3497 3498 /* Record the part after the last comma. */ 3499 add_preprocessor_option (argv[i] + prev, j - prev); 3500 } 3501 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3502 /* The +e options to the C++ front-end. */ 3503 n_switches++; 3504 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3505 { 3506 int j; 3507 /* Split the argument at commas. */ 3508 for (j = 3; argv[i][j]; j++) 3509 n_infiles += (argv[i][j] == ','); 3510 } 3511 else if (strcmp (argv[i], "-Xlinker") == 0) 3512 { 3513 if (i + 1 == argc) 3514 fatal ("argument to `-Xlinker' is missing"); 3515 3516 n_infiles++; 3517 i++; 3518 } 3519 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3520 { 3521 if (i + 1 == argc) 3522 fatal ("argument to `-Xpreprocessor' is missing"); 3523 3524 add_preprocessor_option (argv[i+1], strlen (argv[i+1])); 3525 } 3526 else if (strcmp (argv[i], "-Xassembler") == 0) 3527 { 3528 if (i + 1 == argc) 3529 fatal ("argument to `-Xassembler' is missing"); 3530 3531 add_assembler_option (argv[i+1], strlen (argv[i+1])); 3532 } 3533 else if (strcmp (argv[i], "-l") == 0) 3534 { 3535 if (i + 1 == argc) 3536 fatal ("argument to `-l' is missing"); 3537 3538 n_infiles++; 3539 i++; 3540 } 3541 else if (strncmp (argv[i], "-l", 2) == 0) 3542 n_infiles++; 3543 else if (strcmp (argv[i], "-save-temps") == 0) 3544 { 3545 save_temps_flag = 1; 3546 n_switches++; 3547 } 3548 else if (strcmp (argv[i], "-specs") == 0) 3549 { 3550 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3551 if (++i >= argc) 3552 fatal ("argument to `-specs' is missing"); 3553 3554 user->next = (struct user_specs *) 0; 3555 user->filename = argv[i]; 3556 if (user_specs_tail) 3557 user_specs_tail->next = user; 3558 else 3559 user_specs_head = user; 3560 user_specs_tail = user; 3561 } 3562 else if (strncmp (argv[i], "-specs=", 7) == 0) 3563 { 3564 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3565 if (strlen (argv[i]) == 7) 3566 fatal ("argument to `-specs=' is missing"); 3567 3568 user->next = (struct user_specs *) 0; 3569 user->filename = argv[i] + 7; 3570 if (user_specs_tail) 3571 user_specs_tail->next = user; 3572 else 3573 user_specs_head = user; 3574 user_specs_tail = user; 3575 } 3576 else if (strcmp (argv[i], "-time") == 0) 3577 report_times = 1; 3578 else if (strcmp (argv[i], "-pipe") == 0) 3579 { 3580 /* -pipe has to go into the switches array as well as 3581 setting a flag. */ 3582 use_pipes = 1; 3583 n_switches++; 3584 } 3585 else if (strcmp (argv[i], "-###") == 0) 3586 { 3587 /* This is similar to -v except that there is no execution 3588 of the commands and the echoed arguments are quoted. It 3589 is intended for use in shell scripts to capture the 3590 driver-generated command line. */ 3591 verbose_only_flag++; 3592 verbose_flag++; 3593 } 3594 else if (argv[i][0] == '-' && argv[i][1] != 0) 3595 { 3596 const char *p = &argv[i][1]; 3597 int c = *p; 3598 3599 switch (c) 3600 { 3601 case 'b': 3602 case 'V': 3603 fatal ("`-%c' must come at the start of the command line", c); 3604 break; 3605 3606 case 'B': 3607 { 3608 const char *value; 3609 int len; 3610 3611 if (p[1] == 0 && i + 1 == argc) 3612 fatal ("argument to `-B' is missing"); 3613 if (p[1] == 0) 3614 value = argv[++i]; 3615 else 3616 value = p + 1; 3617 3618 len = strlen (value); 3619 3620 /* Catch the case where the user has forgotten to append a 3621 directory separator to the path. Note, they may be using 3622 -B to add an executable name prefix, eg "i386-elf-", in 3623 order to distinguish between multiple installations of 3624 GCC in the same directory. Hence we must check to see 3625 if appending a directory separator actually makes a 3626 valid directory name. */ 3627 if (! IS_DIR_SEPARATOR (value [len - 1]) 3628 && is_directory (value, "", 0)) 3629 { 3630 char *tmp = xmalloc (len + 2); 3631 strcpy (tmp, value); 3632 tmp[len] = DIR_SEPARATOR; 3633 tmp[++ len] = 0; 3634 value = tmp; 3635 } 3636 3637 /* As a kludge, if the arg is "[foo/]stageN/", just 3638 add "[foo/]include" to the include prefix. */ 3639 if ((len == 7 3640 || (len > 7 3641 && (IS_DIR_SEPARATOR (value[len - 8])))) 3642 && strncmp (value + len - 7, "stage", 5) == 0 3643 && ISDIGIT (value[len - 2]) 3644 && (IS_DIR_SEPARATOR (value[len - 1]))) 3645 { 3646 if (len == 7) 3647 add_prefix (&include_prefixes, "include", NULL, 3648 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3649 else 3650 { 3651 char * string = xmalloc (len + 1); 3652 3653 strncpy (string, value, len - 7); 3654 strcpy (string + len - 7, "include"); 3655 add_prefix (&include_prefixes, string, NULL, 3656 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3657 } 3658 } 3659 3660 add_prefix (&exec_prefixes, value, NULL, 3661 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3662 add_prefix (&startfile_prefixes, value, NULL, 3663 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3664 add_prefix (&include_prefixes, concat (value, "include", NULL), 3665 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3666 n_switches++; 3667 } 3668 break; 3669 3670 case 'v': /* Print our subcommands and print versions. */ 3671 n_switches++; 3672 /* If they do anything other than exactly `-v', don't set 3673 verbose_flag; rather, continue on to give the error. */ 3674 if (p[1] != 0) 3675 break; 3676 verbose_flag++; 3677 break; 3678 3679 case 'S': 3680 case 'c': 3681 if (p[1] == 0) 3682 { 3683 have_c = 1; 3684 n_switches++; 3685 break; 3686 } 3687 goto normal_switch; 3688 3689 case 'o': 3690 have_o = 1; 3691#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 3692 if (! have_c) 3693 { 3694 int skip; 3695 3696 /* Forward scan, just in case -S or -c is specified 3697 after -o. */ 3698 int j = i + 1; 3699 if (p[1] == 0) 3700 ++j; 3701 while (j < argc) 3702 { 3703 if (argv[j][0] == '-') 3704 { 3705 if (SWITCH_CURTAILS_COMPILATION (argv[j][1]) 3706 && argv[j][2] == 0) 3707 { 3708 have_c = 1; 3709 break; 3710 } 3711 else if ((skip = SWITCH_TAKES_ARG (argv[j][1]))) 3712 j += skip - (argv[j][2] != 0); 3713 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))) 3714 j += skip; 3715 } 3716 j++; 3717 } 3718 } 3719#endif 3720#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX) 3721 if (p[1] == 0) 3722 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0); 3723 else 3724 argv[i] = convert_filename (argv[i], ! have_c, 0); 3725#endif 3726 goto normal_switch; 3727 3728 default: 3729 normal_switch: 3730 3731#ifdef MODIFY_TARGET_NAME 3732 is_modify_target_name = 0; 3733 3734 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3735 if (! strcmp (argv[i], modify_target[j].sw)) 3736 { 3737 char *new_name = xmalloc (strlen (modify_target[j].str) 3738 + strlen (spec_machine)); 3739 const char *p, *r; 3740 char *q; 3741 int made_addition = 0; 3742 3743 is_modify_target_name = 1; 3744 for (p = spec_machine, q = new_name; *p != 0; ) 3745 { 3746 if (modify_target[j].add_del == DELETE 3747 && (! strncmp (q, modify_target[j].str, 3748 strlen (modify_target[j].str)))) 3749 p += strlen (modify_target[j].str); 3750 else if (modify_target[j].add_del == ADD 3751 && ! made_addition && *p == '-') 3752 { 3753 for (r = modify_target[j].str; *r != 0; ) 3754 *q++ = *r++; 3755 made_addition = 1; 3756 } 3757 3758 *q++ = *p++; 3759 } 3760 3761 spec_machine = new_name; 3762 } 3763 3764 if (is_modify_target_name) 3765 break; 3766#endif 3767 3768 n_switches++; 3769 3770 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 3771 i += SWITCH_TAKES_ARG (c) - (p[1] != 0); 3772 else if (WORD_SWITCH_TAKES_ARG (p)) 3773 i += WORD_SWITCH_TAKES_ARG (p); 3774 } 3775 } 3776 else 3777 { 3778 n_infiles++; 3779 lang_n_infiles++; 3780 } 3781 } 3782 3783 combine_inputs = (have_c && have_o && lang_n_infiles > 1); 3784 3785 if ((save_temps_flag || report_times) && use_pipes) 3786 { 3787 /* -save-temps overrides -pipe, so that temp files are produced */ 3788 if (save_temps_flag) 3789 error ("warning: -pipe ignored because -save-temps specified"); 3790 /* -time overrides -pipe because we can't get correct stats when 3791 multiple children are running at once. */ 3792 else if (report_times) 3793 error ("warning: -pipe ignored because -time specified"); 3794 3795 use_pipes = 0; 3796 } 3797 3798 /* Set up the search paths before we go looking for config files. */ 3799 3800 /* These come before the md prefixes so that we will find gcc's subcommands 3801 (such as cpp) rather than those of the host system. */ 3802 /* Use 2 as fourth arg meaning try just the machine as a suffix, 3803 as well as trying the machine and the version. */ 3804#ifdef FREEBSD_NATIVE 3805 add_prefix (&exec_prefixes, PREFIX"/bin/", "BINUTILS", 3806 PREFIX_PRIORITY_LAST, 0, warn_std_ptr, 0); 3807#endif /* FREEBSD_NATIVE */ 3808#ifndef OS2 3809 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC", 3810 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3811 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS", 3812 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3813#ifndef FREEBSD_NATIVE 3814 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS", 3815 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3816 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS", 3817 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3818 add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS", 3819 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3820#endif /* FREEBSD_NATIVE */ 3821#endif 3822 3823#ifndef FREEBSD_NATIVE 3824 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS", 3825 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3826 add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS", 3827 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3828#endif /* not FREEBSD_NATIVE */ 3829 3830 tooldir_prefix = concat (tooldir_base_prefix, spec_machine, 3831 dir_separator_str, NULL); 3832 3833 /* If tooldir is relative, base it on exec_prefixes. A relative 3834 tooldir lets us move the installed tree as a unit. 3835 3836 If GCC_EXEC_PREFIX is defined, then we want to add two relative 3837 directories, so that we can search both the user specified directory 3838 and the standard place. */ 3839 3840 if (!IS_ABSOLUTE_PATH (tooldir_prefix)) 3841 { 3842 if (gcc_exec_prefix) 3843 { 3844 char *gcc_exec_tooldir_prefix 3845 = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 3846 spec_version, dir_separator_str, tooldir_prefix, NULL); 3847 3848 add_prefix (&exec_prefixes, 3849 concat (gcc_exec_tooldir_prefix, "bin", 3850 dir_separator_str, NULL), 3851 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3852 add_prefix (&startfile_prefixes, 3853 concat (gcc_exec_tooldir_prefix, "lib", 3854 dir_separator_str, NULL), 3855 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 3856 } 3857 3858 tooldir_prefix = concat (standard_exec_prefix, spec_machine, 3859 dir_separator_str, spec_version, 3860 dir_separator_str, tooldir_prefix, NULL); 3861 } 3862 3863#ifndef FREEBSD_NATIVE 3864 add_prefix (&exec_prefixes, 3865 concat (tooldir_prefix, "bin", dir_separator_str, NULL), 3866 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 0); 3867 add_prefix (&startfile_prefixes, 3868 concat (tooldir_prefix, "lib", dir_separator_str, NULL), 3869 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 3870 3871#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS) 3872 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix, 3873 then consider it to relocate with the rest of the GCC installation 3874 if GCC_EXEC_PREFIX is set. 3875 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */ 3876 if (target_system_root && gcc_exec_prefix) 3877 { 3878 char *tmp_prefix = make_relative_prefix (argv[0], 3879 standard_bindir_prefix, 3880 target_system_root); 3881 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0) 3882 { 3883 target_system_root = tmp_prefix; 3884 target_system_root_changed = 1; 3885 } 3886 } 3887#endif 3888#endif /* FREEBSD_NATIVE */ 3889 3890 /* More prefixes are enabled in main, after we read the specs file 3891 and determine whether this is cross-compilation or not. */ 3892 3893 /* Then create the space for the vectors and scan again. */ 3894 3895 switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr)); 3896 infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile)); 3897 n_switches = 0; 3898 n_infiles = 0; 3899 last_language_n_infiles = -1; 3900 3901 /* This, time, copy the text of each switch and store a pointer 3902 to the copy in the vector of switches. 3903 Store all the infiles in their vector. */ 3904 3905 for (i = 1; i < argc; i++) 3906 { 3907 /* Just skip the switches that were handled by the preceding loop. */ 3908#ifdef MODIFY_TARGET_NAME 3909 is_modify_target_name = 0; 3910 3911 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3912 if (! strcmp (argv[i], modify_target[j].sw)) 3913 is_modify_target_name = 1; 3914 3915 if (is_modify_target_name) 3916 ; 3917 else 3918#endif 3919 if (! strncmp (argv[i], "-Wa,", 4)) 3920 ; 3921 else if (! strncmp (argv[i], "-Wp,", 4)) 3922 ; 3923 else if (! strcmp (argv[i], "-pass-exit-codes")) 3924 ; 3925 else if (! strcmp (argv[i], "-print-search-dirs")) 3926 ; 3927 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3928 ; 3929 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3930 ; 3931 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3932 ; 3933 else if (! strcmp (argv[i], "-print-multi-lib")) 3934 ; 3935 else if (! strcmp (argv[i], "-print-multi-directory")) 3936 ; 3937 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3938 ; 3939 else if (! strcmp (argv[i], "-ftarget-help")) 3940 ; 3941 else if (! strcmp (argv[i], "-fhelp")) 3942 ; 3943 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3944 { 3945 /* Compensate for the +e options to the C++ front-end; 3946 they're there simply for cfront call-compatibility. We do 3947 some magic in default_compilers to pass them down properly. 3948 Note we deliberately start at the `+' here, to avoid passing 3949 -e0 or -e1 down into the linker. */ 3950 switches[n_switches].part1 = &argv[i][0]; 3951 switches[n_switches].args = 0; 3952 switches[n_switches].live_cond = SWITCH_OK; 3953 switches[n_switches].validated = 0; 3954 n_switches++; 3955 } 3956 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3957 { 3958 int prev, j; 3959 /* Split the argument at commas. */ 3960 prev = 4; 3961 for (j = 4; argv[i][j]; j++) 3962 if (argv[i][j] == ',') 3963 { 3964 infiles[n_infiles].language = "*"; 3965 infiles[n_infiles++].name 3966 = save_string (argv[i] + prev, j - prev); 3967 prev = j + 1; 3968 } 3969 /* Record the part after the last comma. */ 3970 infiles[n_infiles].language = "*"; 3971 infiles[n_infiles++].name = argv[i] + prev; 3972 } 3973 else if (strcmp (argv[i], "-Xlinker") == 0) 3974 { 3975 infiles[n_infiles].language = "*"; 3976 infiles[n_infiles++].name = argv[++i]; 3977 } 3978 else if (strcmp (argv[i], "-Xassembler") == 0) 3979 { 3980 infiles[n_infiles].language = "*"; 3981 infiles[n_infiles++].name = argv[++i]; 3982 } 3983 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3984 { 3985 infiles[n_infiles].language = "*"; 3986 infiles[n_infiles++].name = argv[++i]; 3987 } 3988 else if (strcmp (argv[i], "-l") == 0) 3989 { /* POSIX allows separation of -l and the lib arg; 3990 canonicalize by concatenating -l with its arg */ 3991 infiles[n_infiles].language = "*"; 3992 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL); 3993 } 3994 else if (strncmp (argv[i], "-l", 2) == 0) 3995 { 3996 infiles[n_infiles].language = "*"; 3997 infiles[n_infiles++].name = argv[i]; 3998 } 3999 else if (strcmp (argv[i], "-specs") == 0) 4000 i++; 4001 else if (strncmp (argv[i], "-specs=", 7) == 0) 4002 ; 4003 else if (strcmp (argv[i], "-time") == 0) 4004 ; 4005 else if (strcmp (argv[i], "-###") == 0) 4006 ; 4007 else if (argv[i][0] == '-' && argv[i][1] != 0) 4008 { 4009 const char *p = &argv[i][1]; 4010 int c = *p; 4011 4012 if (c == 'x') 4013 { 4014 if (p[1] == 0 && i + 1 == argc) 4015 fatal ("argument to `-x' is missing"); 4016 if (p[1] == 0) 4017 spec_lang = argv[++i]; 4018 else 4019 spec_lang = p + 1; 4020 if (! strcmp (spec_lang, "none")) 4021 /* Suppress the warning if -xnone comes after the last input 4022 file, because alternate command interfaces like g++ might 4023 find it useful to place -xnone after each input file. */ 4024 spec_lang = 0; 4025 else 4026 last_language_n_infiles = n_infiles; 4027 continue; 4028 } 4029 switches[n_switches].part1 = p; 4030 /* Deal with option arguments in separate argv elements. */ 4031 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0)) 4032 || WORD_SWITCH_TAKES_ARG (p)) 4033 { 4034 int j = 0; 4035 int n_args = WORD_SWITCH_TAKES_ARG (p); 4036 4037 if (n_args == 0) 4038 { 4039 /* Count only the option arguments in separate argv elements. */ 4040 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0); 4041 } 4042 if (i + n_args >= argc) 4043 fatal ("argument to `-%s' is missing", p); 4044 switches[n_switches].args 4045 = xmalloc ((n_args + 1) * sizeof(const char *)); 4046 while (j < n_args) 4047 switches[n_switches].args[j++] = argv[++i]; 4048 /* Null-terminate the vector. */ 4049 switches[n_switches].args[j] = 0; 4050 } 4051 else if (strchr (switches_need_spaces, c)) 4052 { 4053 /* On some systems, ld cannot handle some options without 4054 a space. So split the option from its argument. */ 4055 char *part1 = xmalloc (2); 4056 part1[0] = c; 4057 part1[1] = '\0'; 4058 4059 switches[n_switches].part1 = part1; 4060 switches[n_switches].args = xmalloc (2 * sizeof (const char *)); 4061 switches[n_switches].args[0] = xstrdup (p+1); 4062 switches[n_switches].args[1] = 0; 4063 } 4064 else 4065 switches[n_switches].args = 0; 4066 4067 switches[n_switches].live_cond = SWITCH_OK; 4068 switches[n_switches].validated = 0; 4069 switches[n_switches].ordering = 0; 4070 /* These are always valid, since gcc.c itself understands them. */ 4071 if (!strcmp (p, "save-temps") 4072 || !strcmp (p, "static-libgcc") 4073 || !strcmp (p, "shared-libgcc") 4074 || !strcmp (p, "pipe")) 4075 switches[n_switches].validated = 1; 4076 else 4077 { 4078 char ch = switches[n_switches].part1[0]; 4079 if (ch == 'B') 4080 switches[n_switches].validated = 1; 4081 } 4082 n_switches++; 4083 } 4084 else 4085 { 4086#ifdef HAVE_TARGET_OBJECT_SUFFIX 4087 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK)); 4088#endif 4089 4090 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0) 4091 { 4092 perror_with_name (argv[i]); 4093 error_count++; 4094 } 4095 else 4096 { 4097 infiles[n_infiles].language = spec_lang; 4098 infiles[n_infiles++].name = argv[i]; 4099 } 4100 } 4101 } 4102 4103 if (n_infiles == last_language_n_infiles && spec_lang != 0) 4104 error ("warning: `-x %s' after last input file has no effect", spec_lang); 4105 4106 /* Ensure we only invoke each subprocess once. */ 4107 if (target_help_flag || print_help_list) 4108 { 4109 n_infiles = 1; 4110 4111 /* Create a dummy input file, so that we can pass --target-help on to 4112 the various sub-processes. */ 4113 infiles[0].language = "c"; 4114 infiles[0].name = "help-dummy"; 4115 4116 if (target_help_flag) 4117 { 4118 switches[n_switches].part1 = "--target-help"; 4119 switches[n_switches].args = 0; 4120 switches[n_switches].live_cond = SWITCH_OK; 4121 switches[n_switches].validated = 0; 4122 4123 n_switches++; 4124 } 4125 4126 if (print_help_list) 4127 { 4128 switches[n_switches].part1 = "--help"; 4129 switches[n_switches].args = 0; 4130 switches[n_switches].live_cond = SWITCH_OK; 4131 switches[n_switches].validated = 0; 4132 4133 n_switches++; 4134 } 4135 } 4136 4137 switches[n_switches].part1 = 0; 4138 infiles[n_infiles].name = 0; 4139} 4140 4141/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS 4142 and place that in the environment. */ 4143 4144static void 4145set_collect_gcc_options (void) 4146{ 4147 int i; 4148 int first_time; 4149 4150 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to 4151 the compiler. */ 4152 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=", 4153 sizeof ("COLLECT_GCC_OPTIONS=") - 1); 4154 4155 first_time = TRUE; 4156 for (i = 0; (int) i < n_switches; i++) 4157 { 4158 const char *const *args; 4159 const char *p, *q; 4160 if (!first_time) 4161 obstack_grow (&collect_obstack, " ", 1); 4162 4163 first_time = FALSE; 4164 4165 /* Ignore elided switches. */ 4166 if (switches[i].live_cond == SWITCH_IGNORE) 4167 continue; 4168 4169 obstack_grow (&collect_obstack, "'-", 2); 4170 q = switches[i].part1; 4171 while ((p = strchr (q, '\''))) 4172 { 4173 obstack_grow (&collect_obstack, q, p - q); 4174 obstack_grow (&collect_obstack, "'\\''", 4); 4175 q = ++p; 4176 } 4177 obstack_grow (&collect_obstack, q, strlen (q)); 4178 obstack_grow (&collect_obstack, "'", 1); 4179 4180 for (args = switches[i].args; args && *args; args++) 4181 { 4182 obstack_grow (&collect_obstack, " '", 2); 4183 q = *args; 4184 while ((p = strchr (q, '\''))) 4185 { 4186 obstack_grow (&collect_obstack, q, p - q); 4187 obstack_grow (&collect_obstack, "'\\''", 4); 4188 q = ++p; 4189 } 4190 obstack_grow (&collect_obstack, q, strlen (q)); 4191 obstack_grow (&collect_obstack, "'", 1); 4192 } 4193 } 4194 obstack_grow (&collect_obstack, "\0", 1); 4195 putenv (obstack_finish (&collect_obstack)); 4196} 4197 4198/* Process a spec string, accumulating and running commands. */ 4199 4200/* These variables describe the input file name. 4201 input_file_number is the index on outfiles of this file, 4202 so that the output file name can be stored for later use by %o. 4203 input_basename is the start of the part of the input file 4204 sans all directory names, and basename_length is the number 4205 of characters starting there excluding the suffix .c or whatever. */ 4206 4207static const char *input_filename; 4208static int input_file_number; 4209size_t input_filename_length; 4210static int basename_length; 4211static int suffixed_basename_length; 4212static const char *input_basename; 4213static const char *input_suffix; 4214static struct stat input_stat; 4215static int input_stat_set; 4216 4217/* The compiler used to process the current input file. */ 4218static struct compiler *input_file_compiler; 4219 4220/* These are variables used within do_spec and do_spec_1. */ 4221 4222/* Nonzero if an arg has been started and not yet terminated 4223 (with space, tab or newline). */ 4224static int arg_going; 4225 4226/* Nonzero means %d or %g has been seen; the next arg to be terminated 4227 is a temporary file name. */ 4228static int delete_this_arg; 4229 4230/* Nonzero means %w has been seen; the next arg to be terminated 4231 is the output file name of this compilation. */ 4232static int this_is_output_file; 4233 4234/* Nonzero means %s has been seen; the next arg to be terminated 4235 is the name of a library file and we should try the standard 4236 search dirs for it. */ 4237static int this_is_library_file; 4238 4239/* Nonzero means that the input of this command is coming from a pipe. */ 4240static int input_from_pipe; 4241 4242/* Nonnull means substitute this for any suffix when outputting a switches 4243 arguments. */ 4244static const char *suffix_subst; 4245 4246/* Process the spec SPEC and run the commands specified therein. 4247 Returns 0 if the spec is successfully processed; -1 if failed. */ 4248 4249int 4250do_spec (const char *spec) 4251{ 4252 int value; 4253 4254 value = do_spec_2 (spec); 4255 4256 /* Force out any unfinished command. 4257 If -pipe, this forces out the last command if it ended in `|'. */ 4258 if (value == 0) 4259 { 4260 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4261 argbuf_index--; 4262 4263 set_collect_gcc_options (); 4264 4265 if (argbuf_index > 0) 4266 value = execute (); 4267 } 4268 4269 return value; 4270} 4271 4272static int 4273do_spec_2 (const char *spec) 4274{ 4275 const char *string; 4276 int result; 4277 4278 clear_args (); 4279 arg_going = 0; 4280 delete_this_arg = 0; 4281 this_is_output_file = 0; 4282 this_is_library_file = 0; 4283 input_from_pipe = 0; 4284 suffix_subst = NULL; 4285 4286 result = do_spec_1 (spec, 0, NULL); 4287 4288 /* End any pending argument. */ 4289 if (arg_going) 4290 { 4291 obstack_1grow (&obstack, 0); 4292 string = obstack_finish (&obstack); 4293 if (this_is_library_file) 4294 string = find_file (string); 4295 store_arg (string, delete_this_arg, this_is_output_file); 4296 if (this_is_output_file) 4297 outfiles[input_file_number] = string; 4298 arg_going = 0; 4299 } 4300 4301 return result; 4302} 4303 4304 4305/* Process the given spec string and add any new options to the end 4306 of the switches/n_switches array. */ 4307 4308static void 4309do_option_spec (const char *name, const char *spec) 4310{ 4311 unsigned int i, value_count, value_len; 4312 const char *p, *q, *value; 4313 char *tmp_spec, *tmp_spec_p; 4314 4315 if (configure_default_options[0].name == NULL) 4316 return; 4317 4318 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++) 4319 if (strcmp (configure_default_options[i].name, name) == 0) 4320 break; 4321 if (i == ARRAY_SIZE (configure_default_options)) 4322 return; 4323 4324 value = configure_default_options[i].value; 4325 value_len = strlen (value); 4326 4327 /* Compute the size of the final spec. */ 4328 value_count = 0; 4329 p = spec; 4330 while ((p = strstr (p, "%(VALUE)")) != NULL) 4331 { 4332 p ++; 4333 value_count ++; 4334 } 4335 4336 /* Replace each %(VALUE) by the specified value. */ 4337 tmp_spec = alloca (strlen (spec) + 1 4338 + value_count * (value_len - strlen ("%(VALUE)"))); 4339 tmp_spec_p = tmp_spec; 4340 q = spec; 4341 while ((p = strstr (q, "%(VALUE)")) != NULL) 4342 { 4343 memcpy (tmp_spec_p, q, p - q); 4344 tmp_spec_p = tmp_spec_p + (p - q); 4345 memcpy (tmp_spec_p, value, value_len); 4346 tmp_spec_p += value_len; 4347 q = p + strlen ("%(VALUE)"); 4348 } 4349 strcpy (tmp_spec_p, q); 4350 4351 do_self_spec (tmp_spec); 4352} 4353 4354/* Process the given spec string and add any new options to the end 4355 of the switches/n_switches array. */ 4356 4357static void 4358do_self_spec (const char *spec) 4359{ 4360 do_spec_2 (spec); 4361 do_spec_1 (" ", 0, NULL); 4362 4363 if (argbuf_index > 0) 4364 { 4365 int i, first; 4366 4367 first = n_switches; 4368 n_switches += argbuf_index; 4369 switches = xrealloc (switches, 4370 sizeof (struct switchstr) * (n_switches + 1)); 4371 4372 switches[n_switches] = switches[first]; 4373 for (i = 0; i < argbuf_index; i++) 4374 { 4375 struct switchstr *sw; 4376 4377 /* Each switch should start with '-'. */ 4378 if (argbuf[i][0] != '-') 4379 abort (); 4380 4381 sw = &switches[i + first]; 4382 sw->part1 = &argbuf[i][1]; 4383 sw->args = 0; 4384 sw->live_cond = SWITCH_OK; 4385 sw->validated = 0; 4386 sw->ordering = 0; 4387 } 4388 } 4389} 4390 4391/* Process the sub-spec SPEC as a portion of a larger spec. 4392 This is like processing a whole spec except that we do 4393 not initialize at the beginning and we do not supply a 4394 newline by default at the end. 4395 INSWITCH nonzero means don't process %-sequences in SPEC; 4396 in this case, % is treated as an ordinary character. 4397 This is used while substituting switches. 4398 INSWITCH nonzero also causes SPC not to terminate an argument. 4399 4400 Value is zero unless a line was finished 4401 and the command on that line reported an error. */ 4402 4403static int 4404do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part) 4405{ 4406 const char *p = spec; 4407 int c; 4408 int i; 4409 const char *string; 4410 int value; 4411 4412 while ((c = *p++)) 4413 /* If substituting a switch, treat all chars like letters. 4414 Otherwise, NL, SPC, TAB and % are special. */ 4415 switch (inswitch ? 'a' : c) 4416 { 4417 case '\n': 4418 /* End of line: finish any pending argument, 4419 then run the pending command if one has been started. */ 4420 if (arg_going) 4421 { 4422 obstack_1grow (&obstack, 0); 4423 string = obstack_finish (&obstack); 4424 if (this_is_library_file) 4425 string = find_file (string); 4426 store_arg (string, delete_this_arg, this_is_output_file); 4427 if (this_is_output_file) 4428 outfiles[input_file_number] = string; 4429 } 4430 arg_going = 0; 4431 4432 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4433 { 4434 /* A `|' before the newline means use a pipe here, 4435 but only if -pipe was specified. 4436 Otherwise, execute now and don't pass the `|' as an arg. */ 4437 if (use_pipes) 4438 { 4439 input_from_pipe = 1; 4440 break; 4441 } 4442 else 4443 argbuf_index--; 4444 } 4445 4446 set_collect_gcc_options (); 4447 4448 if (argbuf_index > 0) 4449 { 4450 value = execute (); 4451 if (value) 4452 return value; 4453 } 4454 /* Reinitialize for a new command, and for a new argument. */ 4455 clear_args (); 4456 arg_going = 0; 4457 delete_this_arg = 0; 4458 this_is_output_file = 0; 4459 this_is_library_file = 0; 4460 input_from_pipe = 0; 4461 break; 4462 4463 case '|': 4464 /* End any pending argument. */ 4465 if (arg_going) 4466 { 4467 obstack_1grow (&obstack, 0); 4468 string = obstack_finish (&obstack); 4469 if (this_is_library_file) 4470 string = find_file (string); 4471 store_arg (string, delete_this_arg, this_is_output_file); 4472 if (this_is_output_file) 4473 outfiles[input_file_number] = string; 4474 } 4475 4476 /* Use pipe */ 4477 obstack_1grow (&obstack, c); 4478 arg_going = 1; 4479 break; 4480 4481 case '\t': 4482 case ' ': 4483 /* Space or tab ends an argument if one is pending. */ 4484 if (arg_going) 4485 { 4486 obstack_1grow (&obstack, 0); 4487 string = obstack_finish (&obstack); 4488 if (this_is_library_file) 4489 string = find_file (string); 4490 store_arg (string, delete_this_arg, this_is_output_file); 4491 if (this_is_output_file) 4492 outfiles[input_file_number] = string; 4493 } 4494 /* Reinitialize for a new argument. */ 4495 arg_going = 0; 4496 delete_this_arg = 0; 4497 this_is_output_file = 0; 4498 this_is_library_file = 0; 4499 break; 4500 4501 case '%': 4502 switch (c = *p++) 4503 { 4504 case 0: 4505 fatal ("invalid specification! Bug in cc"); 4506 4507 case 'b': 4508 obstack_grow (&obstack, input_basename, basename_length); 4509 arg_going = 1; 4510 break; 4511 4512 case 'B': 4513 obstack_grow (&obstack, input_basename, suffixed_basename_length); 4514 arg_going = 1; 4515 break; 4516 4517 case 'd': 4518 delete_this_arg = 2; 4519 break; 4520 4521 /* Dump out the directories specified with LIBRARY_PATH, 4522 followed by the absolute directories 4523 that we search for startfiles. */ 4524 case 'D': 4525 { 4526 struct prefix_list *pl = startfile_prefixes.plist; 4527 size_t bufsize = 100; 4528 char *buffer = xmalloc (bufsize); 4529 int idx; 4530 4531 for (; pl; pl = pl->next) 4532 { 4533#ifdef RELATIVE_PREFIX_NOT_LINKDIR 4534 /* Used on systems which record the specified -L dirs 4535 and use them to search for dynamic linking. */ 4536 /* Relative directories always come from -B, 4537 and it is better not to use them for searching 4538 at run time. In particular, stage1 loses. */ 4539 if (!IS_ABSOLUTE_PATH (pl->prefix)) 4540 continue; 4541#endif 4542 /* Try subdirectory if there is one. */ 4543 if (multilib_dir != NULL 4544 || (pl->os_multilib && multilib_os_dir != NULL)) 4545 { 4546 const char *multi_dir; 4547 4548 multi_dir = pl->os_multilib ? multilib_os_dir 4549 : multilib_dir; 4550 if (machine_suffix && multilib_dir) 4551 { 4552 if (strlen (pl->prefix) + strlen (machine_suffix) 4553 >= bufsize) 4554 bufsize = (strlen (pl->prefix) 4555 + strlen (machine_suffix)) * 2 + 1; 4556 buffer = xrealloc (buffer, bufsize); 4557 strcpy (buffer, pl->prefix); 4558 strcat (buffer, machine_suffix); 4559 if (is_directory (buffer, multilib_dir, 1)) 4560 { 4561 do_spec_1 ("-L", 0, NULL); 4562#ifdef SPACE_AFTER_L_OPTION 4563 do_spec_1 (" ", 0, NULL); 4564#endif 4565 do_spec_1 (buffer, 1, NULL); 4566 do_spec_1 (multilib_dir, 1, NULL); 4567 /* Make this a separate argument. */ 4568 do_spec_1 (" ", 0, NULL); 4569 } 4570 } 4571 if (!pl->require_machine_suffix) 4572 { 4573 if (is_directory (pl->prefix, multi_dir, 1)) 4574 { 4575 do_spec_1 ("-L", 0, NULL); 4576#ifdef SPACE_AFTER_L_OPTION 4577 do_spec_1 (" ", 0, NULL); 4578#endif 4579 do_spec_1 (pl->prefix, 1, NULL); 4580 do_spec_1 (multi_dir, 1, NULL); 4581 /* Make this a separate argument. */ 4582 do_spec_1 (" ", 0, NULL); 4583 } 4584 } 4585 } 4586 if (machine_suffix) 4587 { 4588 if (is_directory (pl->prefix, machine_suffix, 1)) 4589 { 4590 do_spec_1 ("-L", 0, NULL); 4591#ifdef SPACE_AFTER_L_OPTION 4592 do_spec_1 (" ", 0, NULL); 4593#endif 4594 do_spec_1 (pl->prefix, 1, NULL); 4595 /* Remove slash from machine_suffix. */ 4596 if (strlen (machine_suffix) >= bufsize) 4597 bufsize = strlen (machine_suffix) * 2 + 1; 4598 buffer = xrealloc (buffer, bufsize); 4599 strcpy (buffer, machine_suffix); 4600 idx = strlen (buffer); 4601 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4602 buffer[idx - 1] = 0; 4603 do_spec_1 (buffer, 1, NULL); 4604 /* Make this a separate argument. */ 4605 do_spec_1 (" ", 0, NULL); 4606 } 4607 } 4608 if (!pl->require_machine_suffix) 4609 { 4610 if (is_directory (pl->prefix, "", 1)) 4611 { 4612 do_spec_1 ("-L", 0, NULL); 4613#ifdef SPACE_AFTER_L_OPTION 4614 do_spec_1 (" ", 0, NULL); 4615#endif 4616 /* Remove slash from pl->prefix. */ 4617 if (strlen (pl->prefix) >= bufsize) 4618 bufsize = strlen (pl->prefix) * 2 + 1; 4619 buffer = xrealloc (buffer, bufsize); 4620 strcpy (buffer, pl->prefix); 4621 idx = strlen (buffer); 4622 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4623 buffer[idx - 1] = 0; 4624 do_spec_1 (buffer, 1, NULL); 4625 /* Make this a separate argument. */ 4626 do_spec_1 (" ", 0, NULL); 4627 } 4628 } 4629 } 4630 free (buffer); 4631 } 4632 break; 4633 4634 case 'e': 4635 /* %efoo means report an error with `foo' as error message 4636 and don't execute any more commands for this file. */ 4637 { 4638 const char *q = p; 4639 char *buf; 4640 while (*p != 0 && *p != '\n') 4641 p++; 4642 buf = alloca (p - q + 1); 4643 strncpy (buf, q, p - q); 4644 buf[p - q] = 0; 4645 error ("%s", buf); 4646 return -1; 4647 } 4648 break; 4649 case 'n': 4650 /* %nfoo means report a notice with `foo' on stderr. */ 4651 { 4652 const char *q = p; 4653 char *buf; 4654 while (*p != 0 && *p != '\n') 4655 p++; 4656 buf = alloca (p - q + 1); 4657 strncpy (buf, q, p - q); 4658 buf[p - q] = 0; 4659 notice ("%s\n", buf); 4660 if (*p) 4661 p++; 4662 } 4663 break; 4664 4665 case 'j': 4666 { 4667 struct stat st; 4668 4669 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is 4670 defined, and it is not a directory, and it is 4671 writable, use it. Otherwise, treat this like any 4672 other temporary file. */ 4673 4674 if ((!save_temps_flag) 4675 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode)) 4676 && (access (HOST_BIT_BUCKET, W_OK) == 0)) 4677 { 4678 obstack_grow (&obstack, HOST_BIT_BUCKET, 4679 strlen (HOST_BIT_BUCKET)); 4680 delete_this_arg = 0; 4681 arg_going = 1; 4682 break; 4683 } 4684 } 4685 goto create_temp_file; 4686 case '|': 4687 if (use_pipes) 4688 { 4689 obstack_1grow (&obstack, '-'); 4690 delete_this_arg = 0; 4691 arg_going = 1; 4692 4693 /* consume suffix */ 4694 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4695 p++; 4696 if (p[0] == '%' && p[1] == 'O') 4697 p += 2; 4698 4699 break; 4700 } 4701 goto create_temp_file; 4702 case 'm': 4703 if (use_pipes) 4704 { 4705 /* consume suffix */ 4706 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4707 p++; 4708 if (p[0] == '%' && p[1] == 'O') 4709 p += 2; 4710 4711 break; 4712 } 4713 goto create_temp_file; 4714 case 'g': 4715 case 'u': 4716 case 'U': 4717 create_temp_file: 4718 { 4719 struct temp_name *t; 4720 int suffix_length; 4721 const char *suffix = p; 4722 char *saved_suffix = NULL; 4723 4724 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4725 p++; 4726 suffix_length = p - suffix; 4727 if (p[0] == '%' && p[1] == 'O') 4728 { 4729 p += 2; 4730 /* We don't support extra suffix characters after %O. */ 4731 if (*p == '.' || ISALPHA ((unsigned char) *p)) 4732 abort (); 4733 if (suffix_length == 0) 4734 suffix = TARGET_OBJECT_SUFFIX; 4735 else 4736 { 4737 saved_suffix 4738 = xmalloc (suffix_length 4739 + strlen (TARGET_OBJECT_SUFFIX)); 4740 strncpy (saved_suffix, suffix, suffix_length); 4741 strcpy (saved_suffix + suffix_length, 4742 TARGET_OBJECT_SUFFIX); 4743 } 4744 suffix_length += strlen (TARGET_OBJECT_SUFFIX); 4745 } 4746 4747 /* If the input_filename has the same suffix specified 4748 for the %g, %u, or %U, and -save-temps is specified, 4749 we could end up using that file as an intermediate 4750 thus clobbering the user's source file (.e.g., 4751 gcc -save-temps foo.s would clobber foo.s with the 4752 output of cpp0). So check for this condition and 4753 generate a temp file as the intermediate. */ 4754 4755 if (save_temps_flag) 4756 { 4757 temp_filename_length = basename_length + suffix_length; 4758 temp_filename = alloca (temp_filename_length + 1); 4759 strncpy ((char *) temp_filename, input_basename, basename_length); 4760 strncpy ((char *) temp_filename + basename_length, suffix, 4761 suffix_length); 4762 *((char *) temp_filename + temp_filename_length) = '\0'; 4763 if (strcmp (temp_filename, input_filename) != 0) 4764 { 4765 struct stat st_temp; 4766 4767 /* Note, set_input() resets input_stat_set to 0. */ 4768 if (input_stat_set == 0) 4769 { 4770 input_stat_set = stat (input_filename, &input_stat); 4771 if (input_stat_set >= 0) 4772 input_stat_set = 1; 4773 } 4774 4775 /* If we have the stat for the input_filename 4776 and we can do the stat for the temp_filename 4777 then the they could still refer to the same 4778 file if st_dev/st_ino's are the same. */ 4779 4780 if (input_stat_set != 1 4781 || stat (temp_filename, &st_temp) < 0 4782 || input_stat.st_dev != st_temp.st_dev 4783 || input_stat.st_ino != st_temp.st_ino) 4784 { 4785 temp_filename = save_string (temp_filename, 4786 temp_filename_length + 1); 4787 obstack_grow (&obstack, temp_filename, 4788 temp_filename_length); 4789 arg_going = 1; 4790 delete_this_arg = 0; 4791 break; 4792 } 4793 } 4794 } 4795 4796 /* See if we already have an association of %g/%u/%U and 4797 suffix. */ 4798 for (t = temp_names; t; t = t->next) 4799 if (t->length == suffix_length 4800 && strncmp (t->suffix, suffix, suffix_length) == 0 4801 && t->unique == (c == 'u' || c == 'U' || c == 'j')) 4802 break; 4803 4804 /* Make a new association if needed. %u and %j 4805 require one. */ 4806 if (t == 0 || c == 'u' || c == 'j') 4807 { 4808 if (t == 0) 4809 { 4810 t = xmalloc (sizeof (struct temp_name)); 4811 t->next = temp_names; 4812 temp_names = t; 4813 } 4814 t->length = suffix_length; 4815 if (saved_suffix) 4816 { 4817 t->suffix = saved_suffix; 4818 saved_suffix = NULL; 4819 } 4820 else 4821 t->suffix = save_string (suffix, suffix_length); 4822 t->unique = (c == 'u' || c == 'U' || c == 'j'); 4823 temp_filename = make_temp_file (t->suffix); 4824 temp_filename_length = strlen (temp_filename); 4825 t->filename = temp_filename; 4826 t->filename_length = temp_filename_length; 4827 } 4828 4829 if (saved_suffix) 4830 free (saved_suffix); 4831 4832 obstack_grow (&obstack, t->filename, t->filename_length); 4833 delete_this_arg = 1; 4834 } 4835 arg_going = 1; 4836 break; 4837 4838 case 'i': 4839 if (combine_inputs) 4840 { 4841 for (i = 0; (int) i < n_infiles; i++) 4842 store_arg (infiles[i].name, 0, 0); 4843 } 4844 else 4845 { 4846 obstack_grow (&obstack, input_filename, input_filename_length); 4847 arg_going = 1; 4848 } 4849 break; 4850 4851 case 'I': 4852 { 4853 struct prefix_list *pl = include_prefixes.plist; 4854 4855 if (gcc_exec_prefix) 4856 { 4857 do_spec_1 ("-iprefix", 1, NULL); 4858 /* Make this a separate argument. */ 4859 do_spec_1 (" ", 0, NULL); 4860 do_spec_1 (gcc_exec_prefix, 1, NULL); 4861 do_spec_1 (" ", 0, NULL); 4862 } 4863 4864 if (target_system_root_changed || 4865 (target_system_root && target_sysroot_hdrs_suffix)) 4866 { 4867 do_spec_1 ("-isysroot", 1, NULL); 4868 /* Make this a separate argument. */ 4869 do_spec_1 (" ", 0, NULL); 4870 do_spec_1 (target_system_root, 1, NULL); 4871 if (target_sysroot_hdrs_suffix) 4872 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL); 4873 do_spec_1 (" ", 0, NULL); 4874 } 4875 4876 for (; pl; pl = pl->next) 4877 { 4878 do_spec_1 ("-isystem", 1, NULL); 4879 /* Make this a separate argument. */ 4880 do_spec_1 (" ", 0, NULL); 4881 do_spec_1 (pl->prefix, 1, NULL); 4882 do_spec_1 (" ", 0, NULL); 4883 } 4884 } 4885 break; 4886 4887 case 'o': 4888 { 4889 int max = n_infiles; 4890 max += lang_specific_extra_outfiles; 4891 4892 for (i = 0; i < max; i++) 4893 if (outfiles[i]) 4894 store_arg (outfiles[i], 0, 0); 4895 break; 4896 } 4897 4898 case 'O': 4899 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 4900 arg_going = 1; 4901 break; 4902 4903 case 's': 4904 this_is_library_file = 1; 4905 break; 4906 4907 case 'V': 4908 outfiles[input_file_number] = NULL; 4909 break; 4910 4911 case 'w': 4912 this_is_output_file = 1; 4913 break; 4914 4915 case 'W': 4916 { 4917 int cur_index = argbuf_index; 4918 /* Handle the {...} following the %W. */ 4919 if (*p != '{') 4920 abort (); 4921 p = handle_braces (p + 1); 4922 if (p == 0) 4923 return -1; 4924 /* End any pending argument. */ 4925 if (arg_going) 4926 { 4927 obstack_1grow (&obstack, 0); 4928 string = obstack_finish (&obstack); 4929 if (this_is_library_file) 4930 string = find_file (string); 4931 store_arg (string, delete_this_arg, this_is_output_file); 4932 if (this_is_output_file) 4933 outfiles[input_file_number] = string; 4934 arg_going = 0; 4935 } 4936 /* If any args were output, mark the last one for deletion 4937 on failure. */ 4938 if (argbuf_index != cur_index) 4939 record_temp_file (argbuf[argbuf_index - 1], 0, 1); 4940 break; 4941 } 4942 4943 /* %x{OPTION} records OPTION for %X to output. */ 4944 case 'x': 4945 { 4946 const char *p1 = p; 4947 char *string; 4948 4949 /* Skip past the option value and make a copy. */ 4950 if (*p != '{') 4951 abort (); 4952 while (*p++ != '}') 4953 ; 4954 string = save_string (p1 + 1, p - p1 - 2); 4955 4956 /* See if we already recorded this option. */ 4957 for (i = 0; i < n_linker_options; i++) 4958 if (! strcmp (string, linker_options[i])) 4959 { 4960 free (string); 4961 return 0; 4962 } 4963 4964 /* This option is new; add it. */ 4965 add_linker_option (string, strlen (string)); 4966 } 4967 break; 4968 4969 /* Dump out the options accumulated previously using %x. */ 4970 case 'X': 4971 for (i = 0; i < n_linker_options; i++) 4972 { 4973 do_spec_1 (linker_options[i], 1, NULL); 4974 /* Make each accumulated option a separate argument. */ 4975 do_spec_1 (" ", 0, NULL); 4976 } 4977 break; 4978 4979 /* Dump out the options accumulated previously using -Wa,. */ 4980 case 'Y': 4981 for (i = 0; i < n_assembler_options; i++) 4982 { 4983 do_spec_1 (assembler_options[i], 1, NULL); 4984 /* Make each accumulated option a separate argument. */ 4985 do_spec_1 (" ", 0, NULL); 4986 } 4987 break; 4988 4989 /* Dump out the options accumulated previously using -Wp,. */ 4990 case 'Z': 4991 for (i = 0; i < n_preprocessor_options; i++) 4992 { 4993 do_spec_1 (preprocessor_options[i], 1, NULL); 4994 /* Make each accumulated option a separate argument. */ 4995 do_spec_1 (" ", 0, NULL); 4996 } 4997 break; 4998 4999 /* Here are digits and numbers that just process 5000 a certain constant string as a spec. */ 5001 5002 case '1': 5003 value = do_spec_1 (cc1_spec, 0, NULL); 5004 if (value != 0) 5005 return value; 5006 break; 5007 5008 case '2': 5009 value = do_spec_1 (cc1plus_spec, 0, NULL); 5010 if (value != 0) 5011 return value; 5012 break; 5013 5014 case 'a': 5015 value = do_spec_1 (asm_spec, 0, NULL); 5016 if (value != 0) 5017 return value; 5018 break; 5019 5020 case 'A': 5021 value = do_spec_1 (asm_final_spec, 0, NULL); 5022 if (value != 0) 5023 return value; 5024 break; 5025 5026 case 'C': 5027 { 5028 const char *const spec 5029 = (input_file_compiler->cpp_spec 5030 ? input_file_compiler->cpp_spec 5031 : cpp_spec); 5032 value = do_spec_1 (spec, 0, NULL); 5033 if (value != 0) 5034 return value; 5035 } 5036 break; 5037 5038 case 'E': 5039 value = do_spec_1 (endfile_spec, 0, NULL); 5040 if (value != 0) 5041 return value; 5042 break; 5043 5044 case 'l': 5045 value = do_spec_1 (link_spec, 0, NULL); 5046 if (value != 0) 5047 return value; 5048 break; 5049 5050 case 'L': 5051 value = do_spec_1 (lib_spec, 0, NULL); 5052 if (value != 0) 5053 return value; 5054 break; 5055 5056 case 'G': 5057 value = do_spec_1 (libgcc_spec, 0, NULL); 5058 if (value != 0) 5059 return value; 5060 break; 5061 5062 case 'M': 5063 if (multilib_dir && strcmp (multilib_dir, ".") != 0) 5064 { 5065 char *p; 5066 const char *q; 5067 size_t len; 5068 5069 len = strlen (multilib_dir); 5070 obstack_blank (&obstack, len + 1); 5071 p = obstack_next_free (&obstack) - (len + 1); 5072 5073 *p++ = '_'; 5074 for (q = multilib_dir; *q ; ++q, ++p) 5075 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q); 5076 } 5077 break; 5078 5079 case 'R': 5080 /* We assume there is a directory 5081 separator at the end of this string. */ 5082 if (target_system_root) 5083 { 5084 obstack_grow (&obstack, target_system_root, 5085 strlen (target_system_root)); 5086 if (target_sysroot_suffix) 5087 obstack_grow (&obstack, target_sysroot_suffix, 5088 strlen (target_sysroot_suffix)); 5089 } 5090 break; 5091 5092 case 'S': 5093 value = do_spec_1 (startfile_spec, 0, NULL); 5094 if (value != 0) 5095 return value; 5096 break; 5097 5098 /* Here we define characters other than letters and digits. */ 5099 5100 case '{': 5101 p = handle_braces (p); 5102 if (p == 0) 5103 return -1; 5104 break; 5105 5106 case ':': 5107 p = handle_spec_function (p); 5108 if (p == 0) 5109 return -1; 5110 break; 5111 5112 case '%': 5113 obstack_1grow (&obstack, '%'); 5114 break; 5115 5116 case '.': 5117 { 5118 unsigned len = 0; 5119 5120 while (p[len] && p[len] != ' ' && p[len] != '%') 5121 len++; 5122 suffix_subst = save_string (p - 1, len + 1); 5123 p += len; 5124 } 5125 break; 5126 5127 /* Henceforth ignore the option(s) matching the pattern 5128 after the %<. */ 5129 case '<': 5130 { 5131 unsigned len = 0; 5132 int have_wildcard = 0; 5133 int i; 5134 5135 while (p[len] && p[len] != ' ' && p[len] != '\t') 5136 len++; 5137 5138 if (p[len-1] == '*') 5139 have_wildcard = 1; 5140 5141 for (i = 0; i < n_switches; i++) 5142 if (!strncmp (switches[i].part1, p, len - have_wildcard) 5143 && (have_wildcard || switches[i].part1[len] == '\0')) 5144 { 5145 switches[i].live_cond = SWITCH_IGNORE; 5146 switches[i].validated = 1; 5147 } 5148 5149 p += len; 5150 } 5151 break; 5152 5153 case '*': 5154 if (soft_matched_part) 5155 { 5156 do_spec_1 (soft_matched_part, 1, NULL); 5157 do_spec_1 (" ", 0, NULL); 5158 } 5159 else 5160 /* Catch the case where a spec string contains something like 5161 '%{foo:%*}'. ie there is no * in the pattern on the left 5162 hand side of the :. */ 5163 error ("spec failure: '%%*' has not been initialized by pattern match"); 5164 break; 5165 5166 /* Process a string found as the value of a spec given by name. 5167 This feature allows individual machine descriptions 5168 to add and use their own specs. 5169 %[...] modifies -D options the way %P does; 5170 %(...) uses the spec unmodified. */ 5171 case '[': 5172 error ("warning: use of obsolete %%[ operator in specs"); 5173 case '(': 5174 { 5175 const char *name = p; 5176 struct spec_list *sl; 5177 int len; 5178 5179 /* The string after the S/P is the name of a spec that is to be 5180 processed. */ 5181 while (*p && *p != ')' && *p != ']') 5182 p++; 5183 5184 /* See if it's in the list. */ 5185 for (len = p - name, sl = specs; sl; sl = sl->next) 5186 if (sl->name_len == len && !strncmp (sl->name, name, len)) 5187 { 5188 name = *(sl->ptr_spec); 5189#ifdef DEBUG_SPECS 5190 notice ("Processing spec %c%s%c, which is '%s'\n", 5191 c, sl->name, (c == '(') ? ')' : ']', name); 5192#endif 5193 break; 5194 } 5195 5196 if (sl) 5197 { 5198 if (c == '(') 5199 { 5200 value = do_spec_1 (name, 0, NULL); 5201 if (value != 0) 5202 return value; 5203 } 5204 else 5205 { 5206 char *x = alloca (strlen (name) * 2 + 1); 5207 char *buf = x; 5208 const char *y = name; 5209 int flag = 0; 5210 5211 /* Copy all of NAME into BUF, but put __ after 5212 every -D and at the end of each arg. */ 5213 while (1) 5214 { 5215 if (! strncmp (y, "-D", 2)) 5216 { 5217 *x++ = '-'; 5218 *x++ = 'D'; 5219 *x++ = '_'; 5220 *x++ = '_'; 5221 y += 2; 5222 flag = 1; 5223 continue; 5224 } 5225 else if (flag 5226 && (*y == ' ' || *y == '\t' || *y == '=' 5227 || *y == '}' || *y == 0)) 5228 { 5229 *x++ = '_'; 5230 *x++ = '_'; 5231 flag = 0; 5232 } 5233 if (*y == 0) 5234 break; 5235 else 5236 *x++ = *y++; 5237 } 5238 *x = 0; 5239 5240 value = do_spec_1 (buf, 0, NULL); 5241 if (value != 0) 5242 return value; 5243 } 5244 } 5245 5246 /* Discard the closing paren or bracket. */ 5247 if (*p) 5248 p++; 5249 } 5250 break; 5251 5252 default: 5253 error ("spec failure: unrecognized spec option '%c'", c); 5254 break; 5255 } 5256 break; 5257 5258 case '\\': 5259 /* Backslash: treat next character as ordinary. */ 5260 c = *p++; 5261 5262 /* Fall through. */ 5263 default: 5264 /* Ordinary character: put it into the current argument. */ 5265 obstack_1grow (&obstack, c); 5266 arg_going = 1; 5267 } 5268 5269 /* End of string. If we are processing a spec function, we need to 5270 end any pending argument. */ 5271 if (processing_spec_function && arg_going) 5272 { 5273 obstack_1grow (&obstack, 0); 5274 string = obstack_finish (&obstack); 5275 if (this_is_library_file) 5276 string = find_file (string); 5277 store_arg (string, delete_this_arg, this_is_output_file); 5278 if (this_is_output_file) 5279 outfiles[input_file_number] = string; 5280 arg_going = 0; 5281 } 5282 5283 return 0; 5284} 5285 5286/* Look up a spec function. */ 5287 5288static const struct spec_function * 5289lookup_spec_function (const char *name) 5290{ 5291 static const struct spec_function * const spec_function_tables[] = 5292 { 5293 static_spec_functions, 5294 lang_specific_spec_functions, 5295 }; 5296 const struct spec_function *sf; 5297 unsigned int i; 5298 5299 for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++) 5300 { 5301 for (sf = spec_function_tables[i]; sf->name != NULL; sf++) 5302 if (strcmp (sf->name, name) == 0) 5303 return sf; 5304 } 5305 5306 return NULL; 5307} 5308 5309/* Evaluate a spec function. */ 5310 5311static const char * 5312eval_spec_function (const char *func, const char *args) 5313{ 5314 const struct spec_function *sf; 5315 const char *funcval; 5316 5317 /* Saved spec processing context. */ 5318 int save_argbuf_index; 5319 int save_argbuf_length; 5320 const char **save_argbuf; 5321 5322 int save_arg_going; 5323 int save_delete_this_arg; 5324 int save_this_is_output_file; 5325 int save_this_is_library_file; 5326 int save_input_from_pipe; 5327 const char *save_suffix_subst; 5328 5329 5330 sf = lookup_spec_function (func); 5331 if (sf == NULL) 5332 fatal ("unknown spec function `%s'", func); 5333 5334 /* Push the spec processing context. */ 5335 save_argbuf_index = argbuf_index; 5336 save_argbuf_length = argbuf_length; 5337 save_argbuf = argbuf; 5338 5339 save_arg_going = arg_going; 5340 save_delete_this_arg = delete_this_arg; 5341 save_this_is_output_file = this_is_output_file; 5342 save_this_is_library_file = this_is_library_file; 5343 save_input_from_pipe = input_from_pipe; 5344 save_suffix_subst = suffix_subst; 5345 5346 /* Create a new spec processing context, and build the function 5347 arguments. */ 5348 5349 alloc_args (); 5350 if (do_spec_2 (args) < 0) 5351 fatal ("error in args to spec function `%s'", func); 5352 5353 /* argbuf_index is an index for the next argument to be inserted, and 5354 so contains the count of the args already inserted. */ 5355 5356 funcval = (*sf->func) (argbuf_index, argbuf); 5357 5358 /* Pop the spec processing context. */ 5359 argbuf_index = save_argbuf_index; 5360 argbuf_length = save_argbuf_length; 5361 free (argbuf); 5362 argbuf = save_argbuf; 5363 5364 arg_going = save_arg_going; 5365 delete_this_arg = save_delete_this_arg; 5366 this_is_output_file = save_this_is_output_file; 5367 this_is_library_file = save_this_is_library_file; 5368 input_from_pipe = save_input_from_pipe; 5369 suffix_subst = save_suffix_subst; 5370 5371 return funcval; 5372} 5373 5374/* Handle a spec function call of the form: 5375 5376 %:function(args) 5377 5378 ARGS is processed as a spec in a separate context and split into an 5379 argument vector in the normal fashion. The function returns a string 5380 containing a spec which we then process in the caller's context, or 5381 NULL if no processing is required. */ 5382 5383static const char * 5384handle_spec_function (const char *p) 5385{ 5386 char *func, *args; 5387 const char *endp, *funcval; 5388 int count; 5389 5390 processing_spec_function++; 5391 5392 /* Get the function name. */ 5393 for (endp = p; *endp != '\0'; endp++) 5394 { 5395 if (*endp == '(') /* ) */ 5396 break; 5397 /* Only allow [A-Za-z0-9], -, and _ in function names. */ 5398 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_')) 5399 fatal ("malformed spec function name"); 5400 } 5401 if (*endp != '(') /* ) */ 5402 fatal ("no arguments for spec function"); 5403 func = save_string (p, endp - p); 5404 p = ++endp; 5405 5406 /* Get the arguments. */ 5407 for (count = 0; *endp != '\0'; endp++) 5408 { 5409 /* ( */ 5410 if (*endp == ')') 5411 { 5412 if (count == 0) 5413 break; 5414 count--; 5415 } 5416 else if (*endp == '(') /* ) */ 5417 count++; 5418 } 5419 /* ( */ 5420 if (*endp != ')') 5421 fatal ("malformed spec function arguments"); 5422 args = save_string (p, endp - p); 5423 p = ++endp; 5424 5425 /* p now points to just past the end of the spec function expression. */ 5426 5427 funcval = eval_spec_function (func, args); 5428 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0) 5429 p = NULL; 5430 5431 free (func); 5432 free (args); 5433 5434 processing_spec_function--; 5435 5436 return p; 5437} 5438 5439/* Inline subroutine of handle_braces. Returns true if the current 5440 input suffix matches the atom bracketed by ATOM and END_ATOM. */ 5441static inline bool 5442input_suffix_matches (const char *atom, const char *end_atom) 5443{ 5444 return (input_suffix 5445 && !strncmp (input_suffix, atom, end_atom - atom) 5446 && input_suffix[end_atom - atom] == '\0'); 5447} 5448 5449/* Inline subroutine of handle_braces. Returns true if a switch 5450 matching the atom bracketed by ATOM and END_ATOM appeared on the 5451 command line. */ 5452static inline bool 5453switch_matches (const char *atom, const char *end_atom, int starred) 5454{ 5455 int i; 5456 int len = end_atom - atom; 5457 int plen = starred ? len : -1; 5458 5459 for (i = 0; i < n_switches; i++) 5460 if (!strncmp (switches[i].part1, atom, len) 5461 && (starred || switches[i].part1[len] == '\0') 5462 && check_live_switch (i, plen)) 5463 return true; 5464 5465 return false; 5466} 5467 5468/* Inline subroutine of handle_braces. Mark all of the switches which 5469 match ATOM (extends to END_ATOM; STARRED indicates whether there 5470 was a star after the atom) for later processing. */ 5471static inline void 5472mark_matching_switches (const char *atom, const char *end_atom, int starred) 5473{ 5474 int i; 5475 int len = end_atom - atom; 5476 int plen = starred ? len : -1; 5477 5478 for (i = 0; i < n_switches; i++) 5479 if (!strncmp (switches[i].part1, atom, len) 5480 && (starred || switches[i].part1[len] == '\0') 5481 && check_live_switch (i, plen)) 5482 switches[i].ordering = 1; 5483} 5484 5485/* Inline subroutine of handle_braces. Process all the currently 5486 marked switches through give_switch, and clear the marks. */ 5487static inline void 5488process_marked_switches (void) 5489{ 5490 int i; 5491 5492 for (i = 0; i < n_switches; i++) 5493 if (switches[i].ordering == 1) 5494 { 5495 switches[i].ordering = 0; 5496 give_switch (i, 0); 5497 } 5498} 5499 5500/* Handle a %{ ... } construct. P points just inside the leading {. 5501 Returns a pointer one past the end of the brace block, or 0 5502 if we call do_spec_1 and that returns -1. */ 5503 5504static const char * 5505handle_braces (const char *p) 5506{ 5507 const char *atom, *end_atom; 5508 const char *d_atom = NULL, *d_end_atom = NULL; 5509 5510 bool a_is_suffix; 5511 bool a_is_starred; 5512 bool a_is_negated; 5513 bool a_matched; 5514 5515 bool a_must_be_last = false; 5516 bool ordered_set = false; 5517 bool disjunct_set = false; 5518 bool disj_matched = false; 5519 bool disj_starred = true; 5520 bool n_way_choice = false; 5521 bool n_way_matched = false; 5522 5523#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 5524 5525 do 5526 { 5527 if (a_must_be_last) 5528 abort (); 5529 5530 /* Scan one "atom" (S in the description above of %{}, possibly 5531 with !, ., or * modifiers). */ 5532 a_matched = a_is_suffix = a_is_starred = a_is_negated = false; 5533 5534 SKIP_WHITE(); 5535 if (*p == '!') 5536 p++, a_is_negated = true; 5537 5538 SKIP_WHITE(); 5539 if (*p == '.') 5540 p++, a_is_suffix = true; 5541 5542 atom = p; 5543 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '=' 5544 || *p == ',' || *p == '.' || *p == '@') 5545 p++; 5546 end_atom = p; 5547 5548 if (*p == '*') 5549 p++, a_is_starred = 1; 5550 5551 SKIP_WHITE(); 5552 if (*p == '&' || *p == '}') 5553 { 5554 /* Substitute the switch(es) indicated by the current atom. */ 5555 ordered_set = true; 5556 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix 5557 || atom == end_atom) 5558 abort (); 5559 5560 mark_matching_switches (atom, end_atom, a_is_starred); 5561 5562 if (*p == '}') 5563 process_marked_switches (); 5564 } 5565 else if (*p == '|' || *p == ':') 5566 { 5567 /* Substitute some text if the current atom appears as a switch 5568 or suffix. */ 5569 disjunct_set = true; 5570 if (ordered_set) 5571 abort (); 5572 5573 if (atom == end_atom) 5574 { 5575 if (!n_way_choice || disj_matched || *p == '|' 5576 || a_is_negated || a_is_suffix || a_is_starred) 5577 abort (); 5578 5579 /* An empty term may appear as the last choice of an 5580 N-way choice set; it means "otherwise". */ 5581 a_must_be_last = true; 5582 disj_matched = !n_way_matched; 5583 disj_starred = false; 5584 } 5585 else 5586 { 5587 if (a_is_suffix && a_is_starred) 5588 abort (); 5589 5590 if (!a_is_starred) 5591 disj_starred = false; 5592 5593 /* Don't bother testing this atom if we already have a 5594 match. */ 5595 if (!disj_matched && !n_way_matched) 5596 { 5597 if (a_is_suffix) 5598 a_matched = input_suffix_matches (atom, end_atom); 5599 else 5600 a_matched = switch_matches (atom, end_atom, a_is_starred); 5601 5602 if (a_matched != a_is_negated) 5603 { 5604 disj_matched = true; 5605 d_atom = atom; 5606 d_end_atom = end_atom; 5607 } 5608 } 5609 } 5610 5611 if (*p == ':') 5612 { 5613 /* Found the body, that is, the text to substitute if the 5614 current disjunction matches. */ 5615 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred, 5616 disj_matched && !n_way_matched); 5617 if (p == 0) 5618 return 0; 5619 5620 /* If we have an N-way choice, reset state for the next 5621 disjunction. */ 5622 if (*p == ';') 5623 { 5624 n_way_choice = true; 5625 n_way_matched |= disj_matched; 5626 disj_matched = false; 5627 disj_starred = true; 5628 d_atom = d_end_atom = NULL; 5629 } 5630 } 5631 } 5632 else 5633 abort (); 5634 } 5635 while (*p++ != '}'); 5636 5637 return p; 5638 5639#undef SKIP_WHITE 5640} 5641 5642/* Subroutine of handle_braces. Scan and process a brace substitution body 5643 (X in the description of %{} syntax). P points one past the colon; 5644 ATOM and END_ATOM bracket the first atom which was found to be true 5645 (present) in the current disjunction; STARRED indicates whether all 5646 the atoms in the current disjunction were starred (for syntax validation); 5647 MATCHED indicates whether the disjunction matched or not, and therefore 5648 whether or not the body is to be processed through do_spec_1 or just 5649 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1 5650 returns -1. */ 5651 5652static const char * 5653process_brace_body (const char *p, const char *atom, const char *end_atom, 5654 int starred, int matched) 5655{ 5656 const char *body, *end_body; 5657 unsigned int nesting_level; 5658 bool have_subst = false; 5659 5660 /* Locate the closing } or ;, honoring nested braces. 5661 Trim trailing whitespace. */ 5662 body = p; 5663 nesting_level = 1; 5664 for (;;) 5665 { 5666 if (*p == '{') 5667 nesting_level++; 5668 else if (*p == '}') 5669 { 5670 if (!--nesting_level) 5671 break; 5672 } 5673 else if (*p == ';' && nesting_level == 1) 5674 break; 5675 else if (*p == '%' && p[1] == '*' && nesting_level == 1) 5676 have_subst = true; 5677 else if (*p == '\0') 5678 abort (); 5679 p++; 5680 } 5681 5682 end_body = p; 5683 while (end_body[-1] == ' ' || end_body[-1] == '\t') 5684 end_body--; 5685 5686 if (have_subst && !starred) 5687 abort (); 5688 5689 if (matched) 5690 { 5691 /* Copy the substitution body to permanent storage and execute it. 5692 If have_subst is false, this is a simple matter of running the 5693 body through do_spec_1... */ 5694 char *string = save_string (body, end_body - body); 5695 if (!have_subst) 5696 { 5697 if (do_spec_1 (string, 0, NULL) < 0) 5698 return 0; 5699 } 5700 else 5701 { 5702 /* ... but if have_subst is true, we have to process the 5703 body once for each matching switch, with %* set to the 5704 variant part of the switch. */ 5705 unsigned int hard_match_len = end_atom - atom; 5706 int i; 5707 5708 for (i = 0; i < n_switches; i++) 5709 if (!strncmp (switches[i].part1, atom, hard_match_len) 5710 && check_live_switch (i, hard_match_len)) 5711 { 5712 if (do_spec_1 (string, 0, 5713 &switches[i].part1[hard_match_len]) < 0) 5714 return 0; 5715 /* Pass any arguments this switch has. */ 5716 give_switch (i, 1); 5717 suffix_subst = NULL; 5718 } 5719 } 5720 } 5721 5722 return p; 5723} 5724 5725/* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch 5726 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*} 5727 spec, or -1 if either exact match or %* is used. 5728 5729 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch 5730 whose value does not begin with "no-" is obsoleted by the same value 5731 with the "no-", similarly for a switch with the "no-" prefix. */ 5732 5733static int 5734check_live_switch (int switchnum, int prefix_length) 5735{ 5736 const char *name = switches[switchnum].part1; 5737 int i; 5738 5739 /* In the common case of {<at-most-one-letter>*}, a negating 5740 switch would always match, so ignore that case. We will just 5741 send the conflicting switches to the compiler phase. */ 5742 if (prefix_length >= 0 && prefix_length <= 1) 5743 return 1; 5744 5745 /* If we already processed this switch and determined if it was 5746 live or not, return our past determination. */ 5747 if (switches[switchnum].live_cond != 0) 5748 return switches[switchnum].live_cond > 0; 5749 5750 /* Now search for duplicate in a manner that depends on the name. */ 5751 switch (*name) 5752 { 5753 case 'O': 5754 for (i = switchnum + 1; i < n_switches; i++) 5755 if (switches[i].part1[0] == 'O') 5756 { 5757 switches[switchnum].validated = 1; 5758 switches[switchnum].live_cond = SWITCH_FALSE; 5759 return 0; 5760 } 5761 break; 5762 5763 case 'W': case 'f': case 'm': 5764 if (! strncmp (name + 1, "no-", 3)) 5765 { 5766 /* We have Xno-YYY, search for XYYY. */ 5767 for (i = switchnum + 1; i < n_switches; i++) 5768 if (switches[i].part1[0] == name[0] 5769 && ! strcmp (&switches[i].part1[1], &name[4])) 5770 { 5771 switches[switchnum].validated = 1; 5772 switches[switchnum].live_cond = SWITCH_FALSE; 5773 return 0; 5774 } 5775 } 5776 else 5777 { 5778 /* We have XYYY, search for Xno-YYY. */ 5779 for (i = switchnum + 1; i < n_switches; i++) 5780 if (switches[i].part1[0] == name[0] 5781 && switches[i].part1[1] == 'n' 5782 && switches[i].part1[2] == 'o' 5783 && switches[i].part1[3] == '-' 5784 && !strcmp (&switches[i].part1[4], &name[1])) 5785 { 5786 switches[switchnum].validated = 1; 5787 switches[switchnum].live_cond = SWITCH_FALSE; 5788 return 0; 5789 } 5790 } 5791 break; 5792 } 5793 5794 /* Otherwise the switch is live. */ 5795 switches[switchnum].live_cond = SWITCH_LIVE; 5796 return 1; 5797} 5798 5799/* Pass a switch to the current accumulating command 5800 in the same form that we received it. 5801 SWITCHNUM identifies the switch; it is an index into 5802 the vector of switches gcc received, which is `switches'. 5803 This cannot fail since it never finishes a command line. 5804 5805 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */ 5806 5807static void 5808give_switch (int switchnum, int omit_first_word) 5809{ 5810 if (switches[switchnum].live_cond == SWITCH_IGNORE) 5811 return; 5812 5813 if (!omit_first_word) 5814 { 5815 do_spec_1 ("-", 0, NULL); 5816 do_spec_1 (switches[switchnum].part1, 1, NULL); 5817 } 5818 5819 if (switches[switchnum].args != 0) 5820 { 5821 const char **p; 5822 for (p = switches[switchnum].args; *p; p++) 5823 { 5824 const char *arg = *p; 5825 5826 do_spec_1 (" ", 0, NULL); 5827 if (suffix_subst) 5828 { 5829 unsigned length = strlen (arg); 5830 int dot = 0; 5831 5832 while (length-- && !IS_DIR_SEPARATOR (arg[length])) 5833 if (arg[length] == '.') 5834 { 5835 ((char *)arg)[length] = 0; 5836 dot = 1; 5837 break; 5838 } 5839 do_spec_1 (arg, 1, NULL); 5840 if (dot) 5841 ((char *)arg)[length] = '.'; 5842 do_spec_1 (suffix_subst, 1, NULL); 5843 } 5844 else 5845 do_spec_1 (arg, 1, NULL); 5846 } 5847 } 5848 5849 do_spec_1 (" ", 0, NULL); 5850 switches[switchnum].validated = 1; 5851} 5852 5853/* Search for a file named NAME trying various prefixes including the 5854 user's -B prefix and some standard ones. 5855 Return the absolute file name found. If nothing is found, return NAME. */ 5856 5857static const char * 5858find_file (const char *name) 5859{ 5860 char *newname; 5861 5862 /* Try multilib_dir if it is defined. */ 5863 if (multilib_os_dir != NULL) 5864 { 5865 newname = find_a_file (&startfile_prefixes, name, R_OK, 1); 5866 5867 /* If we don't find it in the multi library dir, then fall 5868 through and look for it in the normal places. */ 5869 if (newname != NULL) 5870 return newname; 5871 } 5872 5873 newname = find_a_file (&startfile_prefixes, name, R_OK, 0); 5874 return newname ? newname : name; 5875} 5876 5877/* Determine whether a directory exists. If LINKER, return 0 for 5878 certain fixed names not needed by the linker. If not LINKER, it is 5879 only important to return 0 if the host machine has a small ARG_MAX 5880 limit. */ 5881 5882static int 5883is_directory (const char *path1, const char *path2, int linker) 5884{ 5885 int len1 = strlen (path1); 5886 int len2 = strlen (path2); 5887 char *path = alloca (3 + len1 + len2); 5888 char *cp; 5889 struct stat st; 5890 5891#ifndef SMALL_ARG_MAX 5892 if (! linker) 5893 return 1; 5894#endif 5895 5896 /* Construct the path from the two parts. Ensure the string ends with "/.". 5897 The resulting path will be a directory even if the given path is a 5898 symbolic link. */ 5899 memcpy (path, path1, len1); 5900 memcpy (path + len1, path2, len2); 5901 cp = path + len1 + len2; 5902 if (!IS_DIR_SEPARATOR (cp[-1])) 5903 *cp++ = DIR_SEPARATOR; 5904 *cp++ = '.'; 5905 *cp = '\0'; 5906 5907#ifndef FREEBSD_NATIVE 5908 /* Exclude directories that the linker is known to search. */ 5909 if (linker 5910 && ((cp - path == 6 5911 && strcmp (path, concat (dir_separator_str, "lib", 5912 dir_separator_str, ".", NULL)) == 0) 5913 || (cp - path == 10 5914 && strcmp (path, concat (dir_separator_str, "usr", 5915 dir_separator_str, "lib", 5916 dir_separator_str, ".", NULL)) == 0))) 5917 return 0; 5918#endif /* FREEBSD_NATIVE */ 5919 5920 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode)); 5921} 5922 5923/* Set up the various global variables to indicate that we're processing 5924 the input file named FILENAME. */ 5925 5926void 5927set_input (const char *filename) 5928{ 5929 const char *p; 5930 5931 input_filename = filename; 5932 input_filename_length = strlen (input_filename); 5933 5934 input_basename = input_filename; 5935#ifdef HAVE_DOS_BASED_FILE_SYSTEM 5936 /* Skip drive name so 'x:foo' is handled properly. */ 5937 if (input_basename[1] == ':') 5938 input_basename += 2; 5939#endif 5940 for (p = input_basename; *p; p++) 5941 if (IS_DIR_SEPARATOR (*p)) 5942 input_basename = p + 1; 5943 5944 /* Find a suffix starting with the last period, 5945 and set basename_length to exclude that suffix. */ 5946 basename_length = strlen (input_basename); 5947 suffixed_basename_length = basename_length; 5948 p = input_basename + basename_length; 5949 while (p != input_basename && *p != '.') 5950 --p; 5951 if (*p == '.' && p != input_basename) 5952 { 5953 basename_length = p - input_basename; 5954 input_suffix = p + 1; 5955 } 5956 else 5957 input_suffix = ""; 5958 5959 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then 5960 we will need to do a stat on the input_filename. The 5961 INPUT_STAT_SET signals that the stat is needed. */ 5962 input_stat_set = 0; 5963} 5964 5965/* On fatal signals, delete all the temporary files. */ 5966 5967static void 5968fatal_error (int signum) 5969{ 5970 signal (signum, SIG_DFL); 5971 delete_failure_queue (); 5972 delete_temp_files (); 5973 /* Get the same signal again, this time not handled, 5974 so its normal effect occurs. */ 5975 kill (getpid (), signum); 5976} 5977 5978extern int main (int, const char **); 5979 5980int 5981main (int argc, const char **argv) 5982{ 5983 size_t i; 5984 int value; 5985 int linker_was_run = 0; 5986 int num_linker_inputs = 0; 5987 char *explicit_link_files; 5988 char *specs_file; 5989 const char *p; 5990 struct user_specs *uptr; 5991 5992 p = argv[0] + strlen (argv[0]); 5993 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) 5994 --p; 5995 programname = p; 5996 5997 xmalloc_set_program_name (programname); 5998 5999#ifdef GCC_DRIVER_HOST_INITIALIZATION 6000 /* Perform host dependent initialization when needed. */ 6001 GCC_DRIVER_HOST_INITIALIZATION; 6002#endif 6003 6004 gcc_init_libintl (); 6005 6006 if (signal (SIGINT, SIG_IGN) != SIG_IGN) 6007 signal (SIGINT, fatal_error); 6008#ifdef SIGHUP 6009 if (signal (SIGHUP, SIG_IGN) != SIG_IGN) 6010 signal (SIGHUP, fatal_error); 6011#endif 6012 if (signal (SIGTERM, SIG_IGN) != SIG_IGN) 6013 signal (SIGTERM, fatal_error); 6014#ifdef SIGPIPE 6015 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) 6016 signal (SIGPIPE, fatal_error); 6017#endif 6018#ifdef SIGCHLD 6019 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will 6020 receive the signal. A different setting is inheritable */ 6021 signal (SIGCHLD, SIG_DFL); 6022#endif 6023 6024 /* Allocate the argument vector. */ 6025 alloc_args (); 6026 6027 obstack_init (&obstack); 6028 6029 /* Build multilib_select, et. al from the separate lines that make up each 6030 multilib selection. */ 6031 { 6032 const char *const *q = multilib_raw; 6033 int need_space; 6034 6035 obstack_init (&multilib_obstack); 6036 while ((p = *q++) != (char *) 0) 6037 obstack_grow (&multilib_obstack, p, strlen (p)); 6038 6039 obstack_1grow (&multilib_obstack, 0); 6040 multilib_select = obstack_finish (&multilib_obstack); 6041 6042 q = multilib_matches_raw; 6043 while ((p = *q++) != (char *) 0) 6044 obstack_grow (&multilib_obstack, p, strlen (p)); 6045 6046 obstack_1grow (&multilib_obstack, 0); 6047 multilib_matches = obstack_finish (&multilib_obstack); 6048 6049 q = multilib_exclusions_raw; 6050 while ((p = *q++) != (char *) 0) 6051 obstack_grow (&multilib_obstack, p, strlen (p)); 6052 6053 obstack_1grow (&multilib_obstack, 0); 6054 multilib_exclusions = obstack_finish (&multilib_obstack); 6055 6056 need_space = FALSE; 6057 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++) 6058 { 6059 if (need_space) 6060 obstack_1grow (&multilib_obstack, ' '); 6061 obstack_grow (&multilib_obstack, 6062 multilib_defaults_raw[i], 6063 strlen (multilib_defaults_raw[i])); 6064 need_space = TRUE; 6065 } 6066 6067 obstack_1grow (&multilib_obstack, 0); 6068 multilib_defaults = obstack_finish (&multilib_obstack); 6069 } 6070 6071 /* Set up to remember the pathname of gcc and any options 6072 needed for collect. We use argv[0] instead of programname because 6073 we need the complete pathname. */ 6074 obstack_init (&collect_obstack); 6075 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1); 6076 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1); 6077 putenv (obstack_finish (&collect_obstack)); 6078 6079#ifdef INIT_ENVIRONMENT 6080 /* Set up any other necessary machine specific environment variables. */ 6081 putenv (INIT_ENVIRONMENT); 6082#endif 6083 6084 /* Make a table of what switches there are (switches, n_switches). 6085 Make a table of specified input files (infiles, n_infiles). 6086 Decode switches that are handled locally. */ 6087 6088 process_command (argc, argv); 6089 6090 /* Initialize the vector of specs to just the default. 6091 This means one element containing 0s, as a terminator. */ 6092 6093 compilers = xmalloc (sizeof default_compilers); 6094 memcpy (compilers, default_compilers, sizeof default_compilers); 6095 n_compilers = n_default_compilers; 6096 6097 /* Read specs from a file if there is one. */ 6098 6099#ifdef FREEBSD_NATIVE 6100 just_machine_suffix = ""; 6101#else /* FREEBSD_NATIVE */ 6102 machine_suffix = concat (spec_machine, dir_separator_str, 6103 spec_version, dir_separator_str, NULL); 6104 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL); 6105#endif /* FREEBSD_NATIVE */ 6106 6107 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0); 6108 /* Read the specs file unless it is a default one. */ 6109 if (specs_file != 0 && strcmp (specs_file, "specs")) 6110 read_specs (specs_file, TRUE); 6111 else 6112 init_spec (); 6113 6114 /* We need to check standard_exec_prefix/just_machine_suffix/specs 6115 for any override of as, ld and libraries. */ 6116 specs_file = (char *) alloca (strlen (FBSD_DATA_PREFIX) 6117 + strlen (just_machine_suffix) 6118 + sizeof ("specs")); 6119 6120 strcpy (specs_file, FBSD_DATA_PREFIX); 6121 strcat (specs_file, just_machine_suffix); 6122 strcat (specs_file, "specs"); 6123 if (access (specs_file, R_OK) == 0) 6124 read_specs (specs_file, TRUE); 6125 6126 /* Process any configure-time defaults specified for the command line 6127 options, via OPTION_DEFAULT_SPECS. */ 6128 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++) 6129 do_option_spec (option_default_specs[i].name, 6130 option_default_specs[i].spec); 6131 6132 /* Process DRIVER_SELF_SPECS, adding any new options to the end 6133 of the command line. */ 6134 6135 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++) 6136 do_self_spec (driver_self_specs[i]); 6137 6138 /* If not cross-compiling, look for executables in the standard 6139 places. */ 6140 if (*cross_compile == '0') 6141 { 6142 if (*md_exec_prefix) 6143 { 6144 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 6145 PREFIX_PRIORITY_LAST, 0, NULL, 0); 6146 } 6147 } 6148 6149 /* Process sysroot_suffix_spec. */ 6150 if (*sysroot_suffix_spec != 0 6151 && do_spec_2 (sysroot_suffix_spec) == 0) 6152 { 6153 if (argbuf_index > 1) 6154 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC."); 6155 else if (argbuf_index == 1) 6156 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]); 6157 } 6158 6159 /* Process sysroot_hdrs_suffix_spec. */ 6160 if (*sysroot_hdrs_suffix_spec != 0 6161 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0) 6162 { 6163 if (argbuf_index > 1) 6164 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC."); 6165 else if (argbuf_index == 1) 6166 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]); 6167 } 6168 6169 /* Look for startfiles in the standard places. */ 6170 if (*startfile_prefix_spec != 0 6171 && do_spec_2 (startfile_prefix_spec) == 0 6172 && do_spec_1 (" ", 0, NULL) == 0) 6173 { 6174 int ndx; 6175 for (ndx = 0; ndx < argbuf_index; ndx++) 6176 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS", 6177 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6178 } 6179 /* We should eventually get rid of all these and stick to 6180 startfile_prefix_spec exclusively. */ 6181 else if (*cross_compile == '0' || target_system_root) 6182 { 6183 if (*md_exec_prefix) 6184 add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 6185 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6186 6187 if (*md_startfile_prefix) 6188 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix, 6189 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6190 6191 if (*md_startfile_prefix_1) 6192 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1, 6193 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6194 6195 /* If standard_startfile_prefix is relative, base it on 6196 standard_exec_prefix. This lets us move the installed tree 6197 as a unit. If GCC_EXEC_PREFIX is defined, base 6198 standard_startfile_prefix on that as well. 6199 6200 If the prefix is relative, only search it for native compilers; 6201 otherwise we will search a directory containing host libraries. */ 6202 if (IS_ABSOLUTE_PATH (standard_startfile_prefix)) 6203 add_sysrooted_prefix (&startfile_prefixes, 6204 standard_startfile_prefix, "BINUTILS", 6205 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6206 else if (*cross_compile == '0') 6207 { 6208 if (gcc_exec_prefix) 6209 add_prefix (&startfile_prefixes, 6210 concat (gcc_exec_prefix, machine_suffix, 6211 standard_startfile_prefix, NULL), 6212 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6213 add_prefix (&startfile_prefixes, 6214 concat (standard_exec_prefix, 6215 machine_suffix, 6216 standard_startfile_prefix, NULL), 6217 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6218 } 6219 6220#ifndef FREEBSD_NATIVE 6221 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_1, 6222 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6223 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_2, 6224 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6225#endif /* not FREEBSD_NATIVE */ 6226#if 0 /* Can cause surprises, and one can use -B./ instead. */ 6227 add_prefix (&startfile_prefixes, "./", NULL, 6228 PREFIX_PRIORITY_LAST, 1, NULL, 0); 6229#endif 6230 } 6231 6232 /* Process any user specified specs in the order given on the command 6233 line. */ 6234 for (uptr = user_specs_head; uptr; uptr = uptr->next) 6235 { 6236 char *filename = find_a_file (&startfile_prefixes, uptr->filename, 6237 R_OK, 0); 6238 read_specs (filename ? filename : uptr->filename, FALSE); 6239 } 6240 6241 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */ 6242 if (gcc_exec_prefix) 6243 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 6244 spec_version, dir_separator_str, NULL); 6245 6246 /* Now we have the specs. 6247 Set the `valid' bits for switches that match anything in any spec. */ 6248 6249 validate_all_switches (); 6250 6251 /* Now that we have the switches and the specs, set 6252 the subdirectory based on the options. */ 6253 set_multilib_dir (); 6254 6255 /* Warn about any switches that no pass was interested in. */ 6256 6257 for (i = 0; (int) i < n_switches; i++) 6258 if (! switches[i].validated) 6259 error ("unrecognized option `-%s'", switches[i].part1); 6260 6261 /* Obey some of the options. */ 6262 6263 if (print_search_dirs) 6264 { 6265 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix); 6266 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0)); 6267 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0)); 6268 return (0); 6269 } 6270 6271 if (print_file_name) 6272 { 6273 printf ("%s\n", find_file (print_file_name)); 6274 return (0); 6275 } 6276 6277 if (print_prog_name) 6278 { 6279 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0); 6280 printf ("%s\n", (newname ? newname : print_prog_name)); 6281 return (0); 6282 } 6283 6284 if (print_multi_lib) 6285 { 6286 print_multilib_info (); 6287 return (0); 6288 } 6289 6290 if (print_multi_directory) 6291 { 6292 if (multilib_dir == NULL) 6293 printf (".\n"); 6294 else 6295 printf ("%s\n", multilib_dir); 6296 return (0); 6297 } 6298 6299 if (print_multi_os_directory) 6300 { 6301 if (multilib_os_dir == NULL) 6302 printf (".\n"); 6303 else 6304 printf ("%s\n", multilib_os_dir); 6305 return (0); 6306 } 6307 6308 if (target_help_flag) 6309 { 6310 /* Print if any target specific options. */ 6311 6312 /* We do not exit here. Instead we have created a fake input file 6313 called 'target-dummy' which needs to be compiled, and we pass this 6314 on to the various sub-processes, along with the --target-help 6315 switch. */ 6316 } 6317 6318 if (print_help_list) 6319 { 6320 display_help (); 6321 6322 if (! verbose_flag) 6323 { 6324 printf (_("\nFor bug reporting instructions, please see:\n")); 6325 printf ("%s.\n", bug_report_url); 6326 6327 return (0); 6328 } 6329 6330 /* We do not exit here. Instead we have created a fake input file 6331 called 'help-dummy' which needs to be compiled, and we pass this 6332 on the various sub-processes, along with the --help switch. */ 6333 } 6334 6335 if (verbose_flag) 6336 { 6337 int n; 6338 const char *thrmod; 6339 6340 notice ("Configured with: %s\n", configuration_arguments); 6341 6342#ifdef THREAD_MODEL_SPEC 6343 /* We could have defined THREAD_MODEL_SPEC to "%*" by default, 6344 but there's no point in doing all this processing just to get 6345 thread_model back. */ 6346 obstack_init (&obstack); 6347 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model); 6348 obstack_1grow (&obstack, '\0'); 6349 thrmod = obstack_finish (&obstack); 6350#else 6351 thrmod = thread_model; 6352#endif 6353 6354 notice ("Thread model: %s\n", thrmod); 6355 6356 /* compiler_version is truncated at the first space when initialized 6357 from version string, so truncate version_string at the first space 6358 before comparing. */ 6359 for (n = 0; version_string[n]; n++) 6360 if (version_string[n] == ' ') 6361 break; 6362 6363 if (! strncmp (version_string, compiler_version, n) 6364 && compiler_version[n] == 0) 6365 notice ("gcc version %s\n", version_string); 6366 else 6367 notice ("gcc driver version %s executing gcc version %s\n", 6368 version_string, compiler_version); 6369 6370 if (n_infiles == 0) 6371 return (0); 6372 } 6373 6374 if (n_infiles == added_libraries) 6375 fatal ("No input files specified"); 6376 6377 /* Make a place to record the compiler output file names 6378 that correspond to the input files. */ 6379 6380 i = n_infiles; 6381 i += lang_specific_extra_outfiles; 6382 outfiles = xcalloc (i, sizeof (char *)); 6383 6384 /* Record which files were specified explicitly as link input. */ 6385 6386 explicit_link_files = xcalloc (1, n_infiles); 6387 6388 if (combine_inputs) 6389 { 6390 int lang_n_infiles = 0; 6391 for (i = 0; (int) i < n_infiles; i++) 6392 { 6393 const char *name = infiles[i].name; 6394 struct compiler *compiler 6395 = lookup_compiler (name, strlen (name), infiles[i].language); 6396 if (compiler == NULL) 6397 error ("%s: linker input file unused because linking not done", 6398 name); 6399 else if (lang_n_infiles > 0 && compiler != input_file_compiler) 6400 fatal ("cannot specify -o with -c or -S and multiple languages"); 6401 else 6402 { 6403 lang_n_infiles++; 6404 input_file_compiler = compiler; 6405 } 6406 } 6407 } 6408 6409 for (i = 0; (int) i < (combine_inputs ? 1 : n_infiles); i++) 6410 { 6411 int this_file_error = 0; 6412 6413 /* Tell do_spec what to substitute for %i. */ 6414 6415 input_file_number = i; 6416 set_input (infiles[i].name); 6417 6418 /* Use the same thing in %o, unless cp->spec says otherwise. */ 6419 6420 outfiles[i] = input_filename; 6421 6422 /* Figure out which compiler from the file's suffix. */ 6423 6424 if (! combine_inputs) 6425 input_file_compiler 6426 = lookup_compiler (infiles[i].name, input_filename_length, 6427 infiles[i].language); 6428 6429 if (input_file_compiler) 6430 { 6431 /* Ok, we found an applicable compiler. Run its spec. */ 6432 6433 if (input_file_compiler->spec[0] == '#') 6434 { 6435 error ("%s: %s compiler not installed on this system", 6436 input_filename, &input_file_compiler->spec[1]); 6437 this_file_error = 1; 6438 } 6439 else 6440 { 6441 value = do_spec (input_file_compiler->spec); 6442 if (value < 0) 6443 this_file_error = 1; 6444 } 6445 } 6446 6447 /* If this file's name does not contain a recognized suffix, 6448 record it as explicit linker input. */ 6449 6450 else 6451 explicit_link_files[i] = 1; 6452 6453 /* Clear the delete-on-failure queue, deleting the files in it 6454 if this compilation failed. */ 6455 6456 if (this_file_error) 6457 { 6458 delete_failure_queue (); 6459 error_count++; 6460 } 6461 /* If this compilation succeeded, don't delete those files later. */ 6462 clear_failure_queue (); 6463 } 6464 6465 /* Reset the output file name to the first input file name, for use 6466 with %b in LINK_SPEC on a target that prefers not to emit a.out 6467 by default. */ 6468 if (n_infiles > 0) 6469 set_input (infiles[0].name); 6470 6471 if (error_count == 0) 6472 { 6473 /* Make sure INPUT_FILE_NUMBER points to first available open 6474 slot. */ 6475 input_file_number = n_infiles; 6476 if (lang_specific_pre_link ()) 6477 error_count++; 6478 } 6479 6480 /* Determine if there are any linker input files. */ 6481 num_linker_inputs = 0; 6482 for (i = 0; (int) i < n_infiles; i++) 6483 if (explicit_link_files[i] || outfiles[i] != NULL) 6484 num_linker_inputs++; 6485 6486 /* Run ld to link all the compiler output files. */ 6487 6488 if (num_linker_inputs > 0 && error_count == 0) 6489 { 6490 int tmp = execution_count; 6491 6492 /* We'll use ld if we can't find collect2. */ 6493 if (! strcmp (linker_name_spec, "collect2")) 6494 { 6495 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0); 6496 if (s == NULL) 6497 linker_name_spec = "ld"; 6498 } 6499 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 6500 for collect. */ 6501 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH"); 6502 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV); 6503 6504 value = do_spec (link_command_spec); 6505 if (value < 0) 6506 error_count = 1; 6507 linker_was_run = (tmp != execution_count); 6508 } 6509 6510 /* If options said don't run linker, 6511 complain about input files to be given to the linker. */ 6512 6513 if (! linker_was_run && error_count == 0) 6514 for (i = 0; (int) i < n_infiles; i++) 6515 if (explicit_link_files[i]) 6516 error ("%s: linker input file unused because linking not done", 6517 outfiles[i]); 6518 6519 /* Delete some or all of the temporary files we made. */ 6520 6521 if (error_count) 6522 delete_failure_queue (); 6523 delete_temp_files (); 6524 6525 if (print_help_list) 6526 { 6527 printf (("\nFor bug reporting instructions, please see:\n")); 6528 printf ("%s\n", bug_report_url); 6529 } 6530 6531 return (signal_count != 0 ? 2 6532 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1) 6533 : 0); 6534} 6535 6536/* Find the proper compilation spec for the file name NAME, 6537 whose length is LENGTH. LANGUAGE is the specified language, 6538 or 0 if this file is to be passed to the linker. */ 6539 6540static struct compiler * 6541lookup_compiler (const char *name, size_t length, const char *language) 6542{ 6543 struct compiler *cp; 6544 6545 /* If this was specified by the user to be a linker input, indicate that. */ 6546 if (language != 0 && language[0] == '*') 6547 return 0; 6548 6549 /* Otherwise, look for the language, if one is spec'd. */ 6550 if (language != 0) 6551 { 6552 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6553 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language)) 6554 return cp; 6555 6556 error ("language %s not recognized", language); 6557 return 0; 6558 } 6559 6560 /* Look for a suffix. */ 6561 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6562 { 6563 if (/* The suffix `-' matches only the file name `-'. */ 6564 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6565 || (strlen (cp->suffix) < length 6566 /* See if the suffix matches the end of NAME. */ 6567 && !strcmp (cp->suffix, 6568 name + length - strlen (cp->suffix)) 6569 )) 6570 break; 6571 } 6572 6573#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM) 6574 /* look again, but case-insensitively this time. */ 6575 if (cp < compilers) 6576 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6577 { 6578 if (/* The suffix `-' matches only the file name `-'. */ 6579 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6580 || (strlen (cp->suffix) < length 6581 /* See if the suffix matches the end of NAME. */ 6582 && ((!strcmp (cp->suffix, 6583 name + length - strlen (cp->suffix)) 6584 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) 6585 && !strcasecmp (cp->suffix, 6586 name + length - strlen (cp->suffix))) 6587 )) 6588 break; 6589 } 6590#endif 6591 6592 if (cp >= compilers) 6593 { 6594 if (cp->spec[0] != '@') 6595 /* A non-alias entry: return it. */ 6596 return cp; 6597 6598 /* An alias entry maps a suffix to a language. 6599 Search for the language; pass 0 for NAME and LENGTH 6600 to avoid infinite recursion if language not found. */ 6601 return lookup_compiler (NULL, 0, cp->spec + 1); 6602 } 6603 return 0; 6604} 6605 6606static char * 6607save_string (const char *s, int len) 6608{ 6609 char *result = xmalloc (len + 1); 6610 6611 memcpy (result, s, len); 6612 result[len] = 0; 6613 return result; 6614} 6615 6616void 6617pfatal_with_name (const char *name) 6618{ 6619 perror_with_name (name); 6620 delete_temp_files (); 6621 exit (1); 6622} 6623 6624static void 6625perror_with_name (const char *name) 6626{ 6627 error ("%s: %s", name, xstrerror (errno)); 6628} 6629 6630static void 6631pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg) 6632{ 6633 if (errmsg_arg) 6634 { 6635 int save_errno = errno; 6636 6637 /* Space for trailing '\0' is in %s. */ 6638 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg)); 6639 sprintf (msg, errmsg_fmt, errmsg_arg); 6640 errmsg_fmt = msg; 6641 6642 errno = save_errno; 6643 } 6644 6645 pfatal_with_name (errmsg_fmt); 6646} 6647 6648/* Output an error message and exit. */ 6649 6650void 6651fancy_abort (void) 6652{ 6653 fatal ("internal gcc abort"); 6654} 6655 6656/* Output an error message and exit. */ 6657 6658void 6659fatal (const char *msgid, ...) 6660{ 6661 va_list ap; 6662 6663 va_start (ap, msgid); 6664 6665 fprintf (stderr, "%s: ", programname); 6666 vfprintf (stderr, _(msgid), ap); 6667 va_end (ap); 6668 fprintf (stderr, "\n"); 6669 delete_temp_files (); 6670 exit (1); 6671} 6672 6673void 6674error (const char *msgid, ...) 6675{ 6676 va_list ap; 6677 6678 va_start (ap, msgid); 6679 fprintf (stderr, "%s: ", programname); 6680 vfprintf (stderr, _(msgid), ap); 6681 va_end (ap); 6682 6683 fprintf (stderr, "\n"); 6684} 6685 6686static void 6687notice (const char *msgid, ...) 6688{ 6689 va_list ap; 6690 6691 va_start (ap, msgid); 6692 vfprintf (stderr, _(msgid), ap); 6693 va_end (ap); 6694} 6695 6696static inline void 6697validate_switches_from_spec (const char *spec) 6698{ 6699 const char *p = spec; 6700 char c; 6701 while ((c = *p++)) 6702 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{'))) 6703 /* We have a switch spec. */ 6704 p = validate_switches (p + 1); 6705} 6706 6707static void 6708validate_all_switches (void) 6709{ 6710 struct compiler *comp; 6711 struct spec_list *spec; 6712 6713 for (comp = compilers; comp->spec; comp++) 6714 validate_switches_from_spec (comp->spec); 6715 6716 /* Look through the linked list of specs read from the specs file. */ 6717 for (spec = specs; spec; spec = spec->next) 6718 validate_switches_from_spec (*spec->ptr_spec); 6719 6720 validate_switches_from_spec (link_command_spec); 6721} 6722 6723/* Look at the switch-name that comes after START 6724 and mark as valid all supplied switches that match it. */ 6725 6726static const char * 6727validate_switches (const char *start) 6728{ 6729 const char *p = start; 6730 const char *atom; 6731 size_t len; 6732 int i; 6733 bool suffix = false; 6734 bool starred = false; 6735 6736#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 6737 6738next_member: 6739 SKIP_WHITE (); 6740 6741 if (*p == '!') 6742 p++; 6743 6744 SKIP_WHITE (); 6745 if (*p == '.') 6746 suffix = true, p++; 6747 6748 atom = p; 6749 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '=' 6750 || *p == ',' || *p == '.' || *p == '@') 6751 p++; 6752 len = p - atom; 6753 6754 if (*p == '*') 6755 starred = true, p++; 6756 6757 SKIP_WHITE (); 6758 6759 if (!suffix) 6760 { 6761 /* Mark all matching switches as valid. */ 6762 for (i = 0; i < n_switches; i++) 6763 if (!strncmp (switches[i].part1, atom, len) 6764 && (starred || switches[i].part1[len] == 0)) 6765 switches[i].validated = 1; 6766 } 6767 6768 if (*p) p++; 6769 if (*p && (p[-1] == '|' || p[-1] == '&')) 6770 goto next_member; 6771 6772 if (*p && p[-1] == ':') 6773 { 6774 while (*p && *p != ';' && *p != '}') 6775 { 6776 if (*p == '%') 6777 { 6778 p++; 6779 if (*p == '{' || *p == '<') 6780 p = validate_switches (p+1); 6781 else if (p[0] == 'W' && p[1] == '{') 6782 p = validate_switches (p+2); 6783 } 6784 else 6785 p++; 6786 } 6787 6788 if (*p) p++; 6789 if (*p && p[-1] == ';') 6790 goto next_member; 6791 } 6792 6793 return p; 6794#undef SKIP_WHITE 6795} 6796 6797struct mdswitchstr 6798{ 6799 const char *str; 6800 int len; 6801}; 6802 6803static struct mdswitchstr *mdswitches; 6804static int n_mdswitches; 6805 6806/* Check whether a particular argument was used. The first time we 6807 canonicalize the switches to keep only the ones we care about. */ 6808 6809static int 6810used_arg (const char *p, int len) 6811{ 6812 struct mswitchstr 6813 { 6814 const char *str; 6815 const char *replace; 6816 int len; 6817 int rep_len; 6818 }; 6819 6820 static struct mswitchstr *mswitches; 6821 static int n_mswitches; 6822 int i, j; 6823 6824 if (!mswitches) 6825 { 6826 struct mswitchstr *matches; 6827 const char *q; 6828 int cnt = 0; 6829 6830 /* Break multilib_matches into the component strings of string 6831 and replacement string. */ 6832 for (q = multilib_matches; *q != '\0'; q++) 6833 if (*q == ';') 6834 cnt++; 6835 6836 matches = alloca ((sizeof (struct mswitchstr)) * cnt); 6837 i = 0; 6838 q = multilib_matches; 6839 while (*q != '\0') 6840 { 6841 matches[i].str = q; 6842 while (*q != ' ') 6843 { 6844 if (*q == '\0') 6845 abort (); 6846 q++; 6847 } 6848 matches[i].len = q - matches[i].str; 6849 6850 matches[i].replace = ++q; 6851 while (*q != ';' && *q != '\0') 6852 { 6853 if (*q == ' ') 6854 abort (); 6855 q++; 6856 } 6857 matches[i].rep_len = q - matches[i].replace; 6858 i++; 6859 if (*q == ';') 6860 q++; 6861 } 6862 6863 /* Now build a list of the replacement string for switches that we care 6864 about. Make sure we allocate at least one entry. This prevents 6865 xmalloc from calling fatal, and prevents us from re-executing this 6866 block of code. */ 6867 mswitches 6868 = xmalloc (sizeof (struct mswitchstr) 6869 * (n_mdswitches + (n_switches ? n_switches : 1))); 6870 for (i = 0; i < n_switches; i++) 6871 { 6872 int xlen = strlen (switches[i].part1); 6873 for (j = 0; j < cnt; j++) 6874 if (xlen == matches[j].len 6875 && ! strncmp (switches[i].part1, matches[j].str, xlen)) 6876 { 6877 mswitches[n_mswitches].str = matches[j].replace; 6878 mswitches[n_mswitches].len = matches[j].rep_len; 6879 mswitches[n_mswitches].replace = (char *) 0; 6880 mswitches[n_mswitches].rep_len = 0; 6881 n_mswitches++; 6882 break; 6883 } 6884 } 6885 6886 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present 6887 on the command line nor any options mutually incompatible with 6888 them. */ 6889 for (i = 0; i < n_mdswitches; i++) 6890 { 6891 const char *r; 6892 6893 for (q = multilib_options; *q != '\0'; q++) 6894 { 6895 while (*q == ' ') 6896 q++; 6897 6898 r = q; 6899 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0 6900 || strchr (" /", q[mdswitches[i].len]) == NULL) 6901 { 6902 while (*q != ' ' && *q != '/' && *q != '\0') 6903 q++; 6904 if (*q != '/') 6905 break; 6906 q++; 6907 } 6908 6909 if (*q != ' ' && *q != '\0') 6910 { 6911 while (*r != ' ' && *r != '\0') 6912 { 6913 q = r; 6914 while (*q != ' ' && *q != '/' && *q != '\0') 6915 q++; 6916 6917 if (used_arg (r, q - r)) 6918 break; 6919 6920 if (*q != '/') 6921 { 6922 mswitches[n_mswitches].str = mdswitches[i].str; 6923 mswitches[n_mswitches].len = mdswitches[i].len; 6924 mswitches[n_mswitches].replace = (char *) 0; 6925 mswitches[n_mswitches].rep_len = 0; 6926 n_mswitches++; 6927 break; 6928 } 6929 6930 r = q + 1; 6931 } 6932 break; 6933 } 6934 } 6935 } 6936 } 6937 6938 for (i = 0; i < n_mswitches; i++) 6939 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len)) 6940 return 1; 6941 6942 return 0; 6943} 6944 6945static int 6946default_arg (const char *p, int len) 6947{ 6948 int i; 6949 6950 for (i = 0; i < n_mdswitches; i++) 6951 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len)) 6952 return 1; 6953 6954 return 0; 6955} 6956 6957/* Work out the subdirectory to use based on the options. The format of 6958 multilib_select is a list of elements. Each element is a subdirectory 6959 name followed by a list of options followed by a semicolon. The format 6960 of multilib_exclusions is the same, but without the preceding 6961 directory. First gcc will check the exclusions, if none of the options 6962 beginning with an exclamation point are present, and all of the other 6963 options are present, then we will ignore this completely. Passing 6964 that, gcc will consider each multilib_select in turn using the same 6965 rules for matching the options. If a match is found, that subdirectory 6966 will be used. */ 6967 6968static void 6969set_multilib_dir (void) 6970{ 6971 const char *p; 6972 unsigned int this_path_len; 6973 const char *this_path, *this_arg; 6974 const char *start, *end; 6975 int not_arg; 6976 int ok, ndfltok, first; 6977 6978 n_mdswitches = 0; 6979 start = multilib_defaults; 6980 while (*start == ' ' || *start == '\t') 6981 start++; 6982 while (*start != '\0') 6983 { 6984 n_mdswitches++; 6985 while (*start != ' ' && *start != '\t' && *start != '\0') 6986 start++; 6987 while (*start == ' ' || *start == '\t') 6988 start++; 6989 } 6990 6991 if (n_mdswitches) 6992 { 6993 int i = 0; 6994 6995 mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches); 6996 for (start = multilib_defaults; *start != '\0'; start = end + 1) 6997 { 6998 while (*start == ' ' || *start == '\t') 6999 start++; 7000 7001 if (*start == '\0') 7002 break; 7003 7004 for (end = start + 1; 7005 *end != ' ' && *end != '\t' && *end != '\0'; end++) 7006 ; 7007 7008 obstack_grow (&multilib_obstack, start, end - start); 7009 obstack_1grow (&multilib_obstack, 0); 7010 mdswitches[i].str = obstack_finish (&multilib_obstack); 7011 mdswitches[i++].len = end - start; 7012 7013 if (*end == '\0') 7014 break; 7015 } 7016 } 7017 7018 p = multilib_exclusions; 7019 while (*p != '\0') 7020 { 7021 /* Ignore newlines. */ 7022 if (*p == '\n') 7023 { 7024 ++p; 7025 continue; 7026 } 7027 7028 /* Check the arguments. */ 7029 ok = 1; 7030 while (*p != ';') 7031 { 7032 if (*p == '\0') 7033 abort (); 7034 7035 if (! ok) 7036 { 7037 ++p; 7038 continue; 7039 } 7040 7041 this_arg = p; 7042 while (*p != ' ' && *p != ';') 7043 { 7044 if (*p == '\0') 7045 abort (); 7046 ++p; 7047 } 7048 7049 if (*this_arg != '!') 7050 not_arg = 0; 7051 else 7052 { 7053 not_arg = 1; 7054 ++this_arg; 7055 } 7056 7057 ok = used_arg (this_arg, p - this_arg); 7058 if (not_arg) 7059 ok = ! ok; 7060 7061 if (*p == ' ') 7062 ++p; 7063 } 7064 7065 if (ok) 7066 return; 7067 7068 ++p; 7069 } 7070 7071 first = 1; 7072 p = multilib_select; 7073 while (*p != '\0') 7074 { 7075 /* Ignore newlines. */ 7076 if (*p == '\n') 7077 { 7078 ++p; 7079 continue; 7080 } 7081 7082 /* Get the initial path. */ 7083 this_path = p; 7084 while (*p != ' ') 7085 { 7086 if (*p == '\0') 7087 abort (); 7088 ++p; 7089 } 7090 this_path_len = p - this_path; 7091 7092 /* Check the arguments. */ 7093 ok = 1; 7094 ndfltok = 1; 7095 ++p; 7096 while (*p != ';') 7097 { 7098 if (*p == '\0') 7099 abort (); 7100 7101 if (! ok) 7102 { 7103 ++p; 7104 continue; 7105 } 7106 7107 this_arg = p; 7108 while (*p != ' ' && *p != ';') 7109 { 7110 if (*p == '\0') 7111 abort (); 7112 ++p; 7113 } 7114 7115 if (*this_arg != '!') 7116 not_arg = 0; 7117 else 7118 { 7119 not_arg = 1; 7120 ++this_arg; 7121 } 7122 7123 /* If this is a default argument, we can just ignore it. 7124 This is true even if this_arg begins with '!'. Beginning 7125 with '!' does not mean that this argument is necessarily 7126 inappropriate for this library: it merely means that 7127 there is a more specific library which uses this 7128 argument. If this argument is a default, we need not 7129 consider that more specific library. */ 7130 ok = used_arg (this_arg, p - this_arg); 7131 if (not_arg) 7132 ok = ! ok; 7133 7134 if (! ok) 7135 ndfltok = 0; 7136 7137 if (default_arg (this_arg, p - this_arg)) 7138 ok = 1; 7139 7140 if (*p == ' ') 7141 ++p; 7142 } 7143 7144 if (ok && first) 7145 { 7146 if (this_path_len != 1 7147 || this_path[0] != '.') 7148 { 7149 char *new_multilib_dir = xmalloc (this_path_len + 1); 7150 char *q; 7151 7152 strncpy (new_multilib_dir, this_path, this_path_len); 7153 new_multilib_dir[this_path_len] = '\0'; 7154 q = strchr (new_multilib_dir, ':'); 7155 if (q != NULL) 7156 *q = '\0'; 7157 multilib_dir = new_multilib_dir; 7158 } 7159 first = 0; 7160 } 7161 7162 if (ndfltok) 7163 { 7164 const char *q = this_path, *end = this_path + this_path_len; 7165 7166 while (q < end && *q != ':') 7167 q++; 7168 if (q < end) 7169 { 7170 char *new_multilib_os_dir = xmalloc (end - q); 7171 memcpy (new_multilib_os_dir, q + 1, end - q - 1); 7172 new_multilib_os_dir[end - q - 1] = '\0'; 7173 multilib_os_dir = new_multilib_os_dir; 7174 break; 7175 } 7176 } 7177 7178 ++p; 7179 } 7180 7181 if (multilib_dir == NULL && multilib_os_dir != NULL 7182 && strcmp (multilib_os_dir, ".") == 0) 7183 { 7184 free ((char *) multilib_os_dir); 7185 multilib_os_dir = NULL; 7186 } 7187 else if (multilib_dir != NULL && multilib_os_dir == NULL) 7188 multilib_os_dir = multilib_dir; 7189} 7190 7191/* Print out the multiple library subdirectory selection 7192 information. This prints out a series of lines. Each line looks 7193 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is 7194 required. Only the desired options are printed out, the negative 7195 matches. The options are print without a leading dash. There are 7196 no spaces to make it easy to use the information in the shell. 7197 Each subdirectory is printed only once. This assumes the ordering 7198 generated by the genmultilib script. Also, we leave out ones that match 7199 the exclusions. */ 7200 7201static void 7202print_multilib_info (void) 7203{ 7204 const char *p = multilib_select; 7205 const char *last_path = 0, *this_path; 7206 int skip; 7207 unsigned int last_path_len = 0; 7208 7209 while (*p != '\0') 7210 { 7211 skip = 0; 7212 /* Ignore newlines. */ 7213 if (*p == '\n') 7214 { 7215 ++p; 7216 continue; 7217 } 7218 7219 /* Get the initial path. */ 7220 this_path = p; 7221 while (*p != ' ') 7222 { 7223 if (*p == '\0') 7224 abort (); 7225 ++p; 7226 } 7227 7228 /* When --disable-multilib was used but target defines 7229 MULTILIB_OSDIRNAMES, entries starting with .: are there just 7230 to find multilib_os_dir, so skip them from output. */ 7231 if (this_path[0] == '.' && this_path[1] == ':') 7232 skip = 1; 7233 7234 /* Check for matches with the multilib_exclusions. We don't bother 7235 with the '!' in either list. If any of the exclusion rules match 7236 all of its options with the select rule, we skip it. */ 7237 { 7238 const char *e = multilib_exclusions; 7239 const char *this_arg; 7240 7241 while (*e != '\0') 7242 { 7243 int m = 1; 7244 /* Ignore newlines. */ 7245 if (*e == '\n') 7246 { 7247 ++e; 7248 continue; 7249 } 7250 7251 /* Check the arguments. */ 7252 while (*e != ';') 7253 { 7254 const char *q; 7255 int mp = 0; 7256 7257 if (*e == '\0') 7258 abort (); 7259 7260 if (! m) 7261 { 7262 ++e; 7263 continue; 7264 } 7265 7266 this_arg = e; 7267 7268 while (*e != ' ' && *e != ';') 7269 { 7270 if (*e == '\0') 7271 abort (); 7272 ++e; 7273 } 7274 7275 q = p + 1; 7276 while (*q != ';') 7277 { 7278 const char *arg; 7279 int len = e - this_arg; 7280 7281 if (*q == '\0') 7282 abort (); 7283 7284 arg = q; 7285 7286 while (*q != ' ' && *q != ';') 7287 { 7288 if (*q == '\0') 7289 abort (); 7290 ++q; 7291 } 7292 7293 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) || 7294 default_arg (this_arg, e - this_arg)) 7295 { 7296 mp = 1; 7297 break; 7298 } 7299 7300 if (*q == ' ') 7301 ++q; 7302 } 7303 7304 if (! mp) 7305 m = 0; 7306 7307 if (*e == ' ') 7308 ++e; 7309 } 7310 7311 if (m) 7312 { 7313 skip = 1; 7314 break; 7315 } 7316 7317 if (*e != '\0') 7318 ++e; 7319 } 7320 } 7321 7322 if (! skip) 7323 { 7324 /* If this is a duplicate, skip it. */ 7325 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len 7326 && ! strncmp (last_path, this_path, last_path_len)); 7327 7328 last_path = this_path; 7329 last_path_len = p - this_path; 7330 } 7331 7332 /* If this directory requires any default arguments, we can skip 7333 it. We will already have printed a directory identical to 7334 this one which does not require that default argument. */ 7335 if (! skip) 7336 { 7337 const char *q; 7338 7339 q = p + 1; 7340 while (*q != ';') 7341 { 7342 const char *arg; 7343 7344 if (*q == '\0') 7345 abort (); 7346 7347 if (*q == '!') 7348 arg = NULL; 7349 else 7350 arg = q; 7351 7352 while (*q != ' ' && *q != ';') 7353 { 7354 if (*q == '\0') 7355 abort (); 7356 ++q; 7357 } 7358 7359 if (arg != NULL 7360 && default_arg (arg, q - arg)) 7361 { 7362 skip = 1; 7363 break; 7364 } 7365 7366 if (*q == ' ') 7367 ++q; 7368 } 7369 } 7370 7371 if (! skip) 7372 { 7373 const char *p1; 7374 7375 for (p1 = last_path; p1 < p && *p1 != ':'; p1++) 7376 putchar (*p1); 7377 putchar (';'); 7378 } 7379 7380 ++p; 7381 while (*p != ';') 7382 { 7383 int use_arg; 7384 7385 if (*p == '\0') 7386 abort (); 7387 7388 if (skip) 7389 { 7390 ++p; 7391 continue; 7392 } 7393 7394 use_arg = *p != '!'; 7395 7396 if (use_arg) 7397 putchar ('@'); 7398 7399 while (*p != ' ' && *p != ';') 7400 { 7401 if (*p == '\0') 7402 abort (); 7403 if (use_arg) 7404 putchar (*p); 7405 ++p; 7406 } 7407 7408 if (*p == ' ') 7409 ++p; 7410 } 7411 7412 if (! skip) 7413 { 7414 /* If there are extra options, print them now. */ 7415 if (multilib_extra && *multilib_extra) 7416 { 7417 int print_at = TRUE; 7418 const char *q; 7419 7420 for (q = multilib_extra; *q != '\0'; q++) 7421 { 7422 if (*q == ' ') 7423 print_at = TRUE; 7424 else 7425 { 7426 if (print_at) 7427 putchar ('@'); 7428 putchar (*q); 7429 print_at = FALSE; 7430 } 7431 } 7432 } 7433 7434 putchar ('\n'); 7435 } 7436 7437 ++p; 7438 } 7439} 7440 7441/* if-exists built-in spec function. 7442 7443 Checks to see if the file specified by the absolute pathname in 7444 ARGS exists. Returns that pathname if found. 7445 7446 The usual use for this function is to check for a library file 7447 (whose name has been expanded with %s). */ 7448 7449static const char * 7450if_exists_spec_function (int argc, const char **argv) 7451{ 7452 /* Must have only one argument. */ 7453 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7454 return argv[0]; 7455 7456 return NULL; 7457} 7458 7459/* if-exists-else built-in spec function. 7460 7461 This is like if-exists, but takes an additional argument which 7462 is returned if the first argument does not exist. */ 7463 7464static const char * 7465if_exists_else_spec_function (int argc, const char **argv) 7466{ 7467 /* Must have exactly two arguments. */ 7468 if (argc != 2) 7469 return NULL; 7470 7471 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7472 return argv[0]; 7473 7474 return argv[1]; 7475}
|