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