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