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