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