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