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